{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Requirements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python 3.6.2 (NOT python 3.7)\n",
    "- Sign up for an Intrinio account at https://intrinio.com/ and obtain an API key. Subscription to the 'US Fundamentals and Stock Prices' subscription (free, trial or paid) is required.\n",
    "\n",
    "Python libaries:\n",
    "- TensorFlow r1.13 \n",
    "- keras\n",
    "- requests\n",
    "- pandas\n",
    "- matplotlib\n",
    "- seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A deep learning price prediction model with TensorFlow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "BASE_URL = 'https://api-v2.intrinio.com'\n",
    "\n",
    "# REPLACE YOUR INTRINIO API KEY HERE!\n",
    "INTRINIO_API_KEY = 'Ojc3NjkzOGNmNDMxMGFiZWZiMmMxMmY0Yjk3MTQzYjdh'\n",
    "\n",
    "def query_intrinio(path, **kwargs):   \n",
    "    url = '%s%s'%(BASE_URL, path)\n",
    "    kwargs['api_key'] = INTRINIO_API_KEY\n",
    "    response = requests.get(url, params=kwargs)\n",
    "\n",
    "    status_code = response.status_code\n",
    "    if status_code == 401: \n",
    "        raise Exception('API key is invalid!')\n",
    "    if status_code == 429: \n",
    "        raise Exception('Page limit hit! Try again in 1 minute')\n",
    "    if status_code != 200: \n",
    "        raise Exception('Request failed with status %s'%status_code)\n",
    "\n",
    "    return response.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from pandas.io.json import json_normalize\n",
    "\n",
    "def get_technicals(ticker, indicator, **kwargs):    \n",
    "    url_pattern = '/securities/%s/prices/technicals/%s'\n",
    "    path = url_pattern%(ticker, indicator)\n",
    "    json_data = query_intrinio(path, **kwargs)\n",
    "\n",
    "    df = json_normalize(json_data.get('technicals'))    \n",
    "    df['date_time'] = pd.to_datetime(df['date_time'])\n",
    "    df = df.set_index('date_time')\n",
    "    df.index = df.index.rename('date')\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "ticker = 'AAPL'\n",
    "query_params = {'start_date': '2013-01-01', 'end_date': '2018-12-31', 'page_size': 365*6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the following lines at one-minute intervals!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_rsi = get_technicals(ticker, 'rsi', **query_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_wr = get_technicals(ticker, 'wr', **query_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_vwap = get_technicals(ticker, 'vwap', **query_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_adtv = get_technicals(ticker, 'adtv', **query_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_ao = get_technicals(ticker, 'ao', **query_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sma_5d = get_technicals(ticker, 'sma', period=5, **query_params)\n",
    "df_sma_5d = df_sma_5d.rename(columns={'sma':'sma_5d'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sma_15d = get_technicals(ticker, 'sma', period=15, **query_params)\n",
    "df_sma_15d = df_sma_15d.rename(columns={'sma':'sma_15d'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sma_30d = get_technicals(ticker, 'sma', period=30, **query_params)\n",
    "df_sma_30d = df_sma_30d.rename(columns={'sma':'sma_30d'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wait one minute before calling get_prices()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_prices(ticker, tag, **params):\n",
    "    url_pattern = '/securities/%s/historical_data/%s'\n",
    "    path = url_pattern%(ticker, tag)\n",
    "    json_data = query_intrinio(path, **params)\n",
    "\n",
    "    df = json_normalize(json_data.get('historical_data'))    \n",
    "    df['date'] = pd.to_datetime(df['date'])\n",
    "    df = df.set_index('date')\n",
    "    df.index = df.index.rename('date')\n",
    "    return df.rename(columns={'value':tag})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_close = get_prices(ticker, 'adj_close_price', **query_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_target = df_close.shift(1).dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df_rsi.join(df_wr).join(df_vwap).join(df_adtv)\\\n",
    "    .join(df_ao).join(df_sma_5d).join(df_sma_15d)\\\n",
    "    .join(df_sma_30d).join(df_target).dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>rsi</th>\n",
       "      <th>wr</th>\n",
       "      <th>vwap</th>\n",
       "      <th>adtv</th>\n",
       "      <th>ao</th>\n",
       "      <th>sma_5d</th>\n",
       "      <th>sma_15d</th>\n",
       "      <th>sma_30d</th>\n",
       "      <th>adj_close_price</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-12-28</th>\n",
       "      <td>35.88289</td>\n",
       "      <td>-62.894534</td>\n",
       "      <td>216.376505</td>\n",
       "      <td>4.693932e+07</td>\n",
       "      <td>-21.924007</td>\n",
       "      <td>153.422</td>\n",
       "      <td>161.806</td>\n",
       "      <td>171.163333</td>\n",
       "      <td>157.066371</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 rsi         wr        vwap          adtv         ao   sma_5d  \\\n",
       "date                                                                            \n",
       "2018-12-28  35.88289 -62.894534  216.376505  4.693932e+07 -21.924007  153.422   \n",
       "\n",
       "            sma_15d     sma_30d  adj_close_price  \n",
       "date                                              \n",
       "2018-12-28  161.806  171.163333       157.066371  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Workaround when Intrinio API key have expired"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section is optional.\n",
    "\n",
    "When the given Intrinio API key expires, the above codes will fail to fetch from the server.\n",
    "As a temporary workaround, load the dataset from disk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>rsi</th>\n",
       "      <th>wr</th>\n",
       "      <th>vwap</th>\n",
       "      <th>adtv</th>\n",
       "      <th>ao</th>\n",
       "      <th>sma_5d</th>\n",
       "      <th>sma_15d</th>\n",
       "      <th>sma_30d</th>\n",
       "      <th>adj_close_price</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-12-28</th>\n",
       "      <td>35.88289</td>\n",
       "      <td>-62.894534</td>\n",
       "      <td>216.376505</td>\n",
       "      <td>4.693932e+07</td>\n",
       "      <td>-21.924007</td>\n",
       "      <td>153.422</td>\n",
       "      <td>161.806</td>\n",
       "      <td>171.163333</td>\n",
       "      <td>157.066371</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 rsi         wr        vwap          adtv         ao   sma_5d  \\\n",
       "date                                                                            \n",
       "2018-12-28  35.88289 -62.894534  216.376505  4.693932e+07 -21.924007  153.422   \n",
       "\n",
       "            sma_15d     sma_30d  adj_close_price  \n",
       "date                                              \n",
       "2018-12-28  161.806  171.163333       157.066371  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_pickle('files/chapter11/df_independent_2013_2018')\n",
    "df.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>adj_close_price</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-12-31</th>\n",
       "      <td>157.066371</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            adj_close_price\n",
       "date                       \n",
       "2018-12-31       157.066371"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_close = pd.read_pickle('files/chapter11/df_aapl_2013_2018')\n",
    "df_close.head(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Splitting and scaling the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = df['2017':'2013']\n",
    "df_test = df['2018']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "scaler = MinMaxScaler(feature_range=(-1, 1))\n",
    "train_data = scaler.fit_transform(df_train.values)\n",
    "test_data = scaler.transform(df_test.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = train_data[:, :-1]\n",
    "y_train = train_data[:, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_test = test_data[:, :-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building an artificial neural network with TensorFlow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Phase 1: Assembling the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "num_features = x_train.shape[1]\n",
    "\n",
    "x = tf.placeholder(dtype=tf.float32, shape=[None, num_features])\n",
    "y = tf.placeholder(dtype=tf.float32, shape=[None])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "nl_1, nl_2, nl_3, nl_4 = 512, 256, 128, 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "wi = tf.contrib.layers.variance_scaling_initializer(\n",
    "    mode='FAN_AVG', uniform=True, factor=1)\n",
    "zi = tf.zeros_initializer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4 Hidden layers\n",
    "wt_hidden_1 = tf.Variable(wi([num_features, nl_1]))\n",
    "bias_hidden_1 = tf.Variable(zi([nl_1]))\n",
    "\n",
    "wt_hidden_2 = tf.Variable(wi([nl_1, nl_2]))\n",
    "bias_hidden_2 = tf.Variable(zi([nl_2]))\n",
    "\n",
    "wt_hidden_3 = tf.Variable(wi([nl_2, nl_3]))\n",
    "bias_hidden_3 = tf.Variable(zi([nl_3]))\n",
    "\n",
    "wt_hidden_4 = tf.Variable(wi([nl_3, nl_4]))\n",
    "bias_hidden_4 = tf.Variable(zi([nl_4]))\n",
    "\n",
    "# Output layer\n",
    "wt_out = tf.Variable(wi([nl_4, 1]))\n",
    "bias_out = tf.Variable(zi([1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden_1 = tf.nn.relu(\n",
    "    tf.add(tf.matmul(x, wt_hidden_1), bias_hidden_1))\n",
    "hidden_2 = tf.nn.relu(\n",
    "    tf.add(tf.matmul(hidden_1, wt_hidden_2), bias_hidden_2))\n",
    "hidden_3 = tf.nn.relu(\n",
    "    tf.add(tf.matmul(hidden_2, wt_hidden_3), bias_hidden_3))\n",
    "hidden_4 = tf.nn.relu(\n",
    "    tf.add(tf.matmul(hidden_3, wt_hidden_4), bias_hidden_4))\n",
    "out = tf.transpose(tf.add(tf.matmul(hidden_4, wt_out), bias_out))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "mse = tf.reduce_mean(tf.squared_difference(out, y)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer().minimize(mse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Phase 2: training our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "session = tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import arange\n",
    "from numpy.random import permutation\n",
    "\n",
    "BATCH_SIZE = 100\n",
    "EPOCHS = 100\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "    # Shuffle the training data\n",
    "    shuffle_data = permutation(arange(len(y_train)))\n",
    "    x_train = x_train[shuffle_data]\n",
    "    y_train = y_train[shuffle_data]\n",
    "\n",
    "    # Mini-batch training\n",
    "    for i in range(len(y_train)//BATCH_SIZE):\n",
    "        start = i*BATCH_SIZE\n",
    "        batch_x = x_train[start:start+BATCH_SIZE]\n",
    "        batch_y = y_train[start:start+BATCH_SIZE]\n",
    "        session.run(optimizer, feed_dict={x: batch_x, y: batch_y})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "[predicted_values] = session.run(out, feed_dict={x: x_test})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted_scaled_data = test_data.copy()\n",
    "predicted_scaled_data[:, -1] = predicted_values\n",
    "predicted_values = scaler.inverse_transform(predicted_scaled_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = predicted_values[:, -1][::-1]\n",
    "actual = df_close['2018']['adj_close_price'].values[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.title('Actual and predicted prices of AAPL 2018')\n",
    "plt.plot(actual, label='Actual')\n",
    "plt.plot(predictions, linestyle='dotted', label='Predicted')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Credit card payment default prediction with Keras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Obtaining the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv('files/chapter11/default_cc_clients.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 30000 entries, 0 to 29999\n",
      "Data columns (total 24 columns):\n",
      "LIMIT_BAL                     30000 non-null int64\n",
      "SEX                           30000 non-null int64\n",
      "EDUCATION                     30000 non-null int64\n",
      "MARRIAGE                      30000 non-null int64\n",
      "AGE                           30000 non-null int64\n",
      "PAY_0                         30000 non-null int64\n",
      "PAY_2                         30000 non-null int64\n",
      "PAY_3                         30000 non-null int64\n",
      "PAY_4                         30000 non-null int64\n",
      "PAY_5                         30000 non-null int64\n",
      "PAY_6                         30000 non-null int64\n",
      "BILL_AMT1                     30000 non-null int64\n",
      "BILL_AMT2                     30000 non-null int64\n",
      "BILL_AMT3                     30000 non-null int64\n",
      "BILL_AMT4                     30000 non-null int64\n",
      "BILL_AMT5                     30000 non-null int64\n",
      "BILL_AMT6                     30000 non-null int64\n",
      "PAY_AMT1                      30000 non-null int64\n",
      "PAY_AMT2                      30000 non-null int64\n",
      "PAY_AMT3                      30000 non-null int64\n",
      "PAY_AMT4                      30000 non-null int64\n",
      "PAY_AMT5                      30000 non-null int64\n",
      "PAY_AMT6                      30000 non-null int64\n",
      "default payment next month    30000 non-null int64\n",
      "dtypes: int64(24)\n",
      "memory usage: 5.5 MB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>LIMIT_BAL</th>\n",
       "      <th>SEX</th>\n",
       "      <th>EDUCATION</th>\n",
       "      <th>MARRIAGE</th>\n",
       "      <th>AGE</th>\n",
       "      <th>PAY_0</th>\n",
       "      <th>PAY_2</th>\n",
       "      <th>PAY_3</th>\n",
       "      <th>PAY_4</th>\n",
       "      <th>PAY_5</th>\n",
       "      <th>...</th>\n",
       "      <th>BILL_AMT4</th>\n",
       "      <th>BILL_AMT5</th>\n",
       "      <th>BILL_AMT6</th>\n",
       "      <th>PAY_AMT1</th>\n",
       "      <th>PAY_AMT2</th>\n",
       "      <th>PAY_AMT3</th>\n",
       "      <th>PAY_AMT4</th>\n",
       "      <th>PAY_AMT5</th>\n",
       "      <th>PAY_AMT6</th>\n",
       "      <th>default payment next month</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20000</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>24</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>-1</td>\n",
       "      <td>-1</td>\n",
       "      <td>-2</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>689</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 24 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   LIMIT_BAL  SEX  EDUCATION  MARRIAGE  AGE  PAY_0  PAY_2  PAY_3  PAY_4  \\\n",
       "0      20000    2          2         1   24      2      2     -1     -1   \n",
       "\n",
       "   PAY_5             ...              BILL_AMT4  BILL_AMT5  BILL_AMT6  \\\n",
       "0     -2             ...                      0          0          0   \n",
       "\n",
       "   PAY_AMT1  PAY_AMT2  PAY_AMT3  PAY_AMT4  PAY_AMT5  PAY_AMT6  \\\n",
       "0         0       689         0         0         0         0   \n",
       "\n",
       "   default payment next month  \n",
       "0                           1  \n",
       "\n",
       "[1 rows x 24 columns]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Splitting and scaling the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_columns= df.columns[:-1]\n",
    "features = df.loc[:, feature_columns]\n",
    "target = df.loc[:, 'default payment next month']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "train_features, test_features, train_target, test_target = \\\n",
    "    train_test_split(features, target, test_size=0.20, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "train_x, train_y = np.array(train_features), np.array(train_target)\n",
    "test_x, test_y = np.array(test_features), np.array(test_target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\python3\\lib\\site-packages\\sklearn\\utils\\validation.py:595: DataConversionWarning: Data with input dtype int64 was converted to float64 by MinMaxScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "train_scaled_x = scaler.fit_transform(train_x)\n",
    "test_scaled_x = scaler.transform(test_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Designing a deep neural network with 5 hidden layers using Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import Dropout\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "\n",
    "num_features = train_scaled_x.shape[1]\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Dense(80, input_dim=num_features, activation='relu'))\n",
    "model.add(Dropout(0.2))\n",
    "model.add(Dense(80, activation='relu'))\n",
    "model.add(Dropout(0.2))\n",
    "model.add(Dense(40, activation='relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 80)                1920      \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 80)                0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 80)                6480      \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 80)                0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 40)                3240      \n",
      "_________________________________________________________________\n",
      "batch_normalization_1 (Batch (None, 40)                160       \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 1)                 41        \n",
      "=================================================================\n",
      "Total params: 11,841\n",
      "Trainable params: 11,761\n",
      "Non-trainable params: 80\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "model.compile(optimizer=tf.train.AdamOptimizer(), \n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 19200 samples, validate on 4800 samples\n",
      "Epoch 1/100\n",
      "19200/19200 [==============================] - 3s 160us/step - loss: 0.5077 - acc: 0.7770 - val_loss: 0.4662 - val_acc: 0.8033\n",
      "Epoch 2/100\n",
      "19200/19200 [==============================] - 2s 99us/step - loss: 0.4666 - acc: 0.8049 - val_loss: 0.4646 - val_acc: 0.8058\n",
      "Epoch 3/100\n",
      "19200/19200 [==============================] - 2s 106us/step - loss: 0.4579 - acc: 0.8076 - val_loss: 0.4626 - val_acc: 0.8040\n",
      "Epoch 4/100\n",
      "19200/19200 [==============================] - 2s 105us/step - loss: 0.4544 - acc: 0.8088 - val_loss: 0.4536 - val_acc: 0.8083\n",
      "Epoch 5/100\n",
      "19200/19200 [==============================] - 2s 115us/step - loss: 0.4527 - acc: 0.8116 - val_loss: 0.4531 - val_acc: 0.8067\n",
      "Epoch 6/100\n",
      "19200/19200 [==============================] - 2s 106us/step - loss: 0.4498 - acc: 0.8127 - val_loss: 0.4540 - val_acc: 0.8123\n",
      "Epoch 7/100\n",
      "19200/19200 [==============================] - 2s 123us/step - loss: 0.4474 - acc: 0.8133 - val_loss: 0.4513 - val_acc: 0.8137\n",
      "Epoch 8/100\n",
      "19200/19200 [==============================] - 2s 122us/step - loss: 0.4465 - acc: 0.8135 - val_loss: 0.4536 - val_acc: 0.8106\n",
      "Epoch 9/100\n",
      "19200/19200 [==============================] - 2s 118us/step - loss: 0.4449 - acc: 0.8145 - val_loss: 0.4490 - val_acc: 0.8096\n",
      "Epoch 10/100\n",
      "19200/19200 [==============================] - 2s 110us/step - loss: 0.4453 - acc: 0.8143 - val_loss: 0.4467 - val_acc: 0.8142\n",
      "Epoch 11/100\n",
      "19200/19200 [==============================] - 2s 107us/step - loss: 0.4425 - acc: 0.8149 - val_loss: 0.4513 - val_acc: 0.8117\n",
      "Epoch 12/100\n",
      "19200/19200 [==============================] - 2s 116us/step - loss: 0.4421 - acc: 0.8161 - val_loss: 0.4454 - val_acc: 0.8127\n",
      "Epoch 13/100\n",
      "19200/19200 [==============================] - 2s 108us/step - loss: 0.4400 - acc: 0.8155 - val_loss: 0.4483 - val_acc: 0.8081\n",
      "Epoch 14/100\n",
      "19200/19200 [==============================] - 2s 121us/step - loss: 0.4403 - acc: 0.8165 - val_loss: 0.4440 - val_acc: 0.8137\n",
      "Epoch 15/100\n",
      "19200/19200 [==============================] - 2s 115us/step - loss: 0.4395 - acc: 0.8172 - val_loss: 0.4471 - val_acc: 0.8121\n",
      "Epoch 16/100\n",
      "19200/19200 [==============================] - 3s 134us/step - loss: 0.4399 - acc: 0.8174 - val_loss: 0.4433 - val_acc: 0.8142\n",
      "Epoch 17/100\n",
      "19200/19200 [==============================] - 2s 120us/step - loss: 0.4375 - acc: 0.8171 - val_loss: 0.4464 - val_acc: 0.8131\n",
      "Epoch 18/100\n",
      "19200/19200 [==============================] - 3s 135us/step - loss: 0.4366 - acc: 0.8189 - val_loss: 0.4475 - val_acc: 0.8140\n",
      "Epoch 19/100\n",
      "19200/19200 [==============================] - 2s 119us/step - loss: 0.4374 - acc: 0.8178 - val_loss: 0.4520 - val_acc: 0.8119\n",
      "Epoch 20/100\n",
      "19200/19200 [==============================] - 2s 129us/step - loss: 0.4368 - acc: 0.8166 - val_loss: 0.4445 - val_acc: 0.8150\n",
      "Epoch 21/100\n",
      "19200/19200 [==============================] - 2s 121us/step - loss: 0.4360 - acc: 0.8174 - val_loss: 0.4395 - val_acc: 0.8156\n",
      "Epoch 22/100\n",
      "19200/19200 [==============================] - 2s 114us/step - loss: 0.4377 - acc: 0.8166 - val_loss: 0.4462 - val_acc: 0.8142\n",
      "Epoch 23/100\n",
      "19200/19200 [==============================] - 2s 112us/step - loss: 0.4363 - acc: 0.8170 - val_loss: 0.4436 - val_acc: 0.8140\n",
      "Epoch 24/100\n",
      "19200/19200 [==============================] - 2s 122us/step - loss: 0.4341 - acc: 0.8184 - val_loss: 0.4447 - val_acc: 0.8146\n",
      "Epoch 25/100\n",
      "19200/19200 [==============================] - 2s 112us/step - loss: 0.4357 - acc: 0.8174 - val_loss: 0.4491 - val_acc: 0.8113\n",
      "Epoch 26/100\n",
      "19200/19200 [==============================] - 2s 130us/step - loss: 0.4358 - acc: 0.8178 - val_loss: 0.4427 - val_acc: 0.8148\n",
      "Epoch 27/100\n",
      "19200/19200 [==============================] - 3s 131us/step - loss: 0.4358 - acc: 0.8189 - val_loss: 0.4401 - val_acc: 0.8165\n",
      "Epoch 28/100\n",
      "19200/19200 [==============================] - 2s 107us/step - loss: 0.4355 - acc: 0.8195 - val_loss: 0.4417 - val_acc: 0.8127\n",
      "Epoch 29/100\n",
      "19200/19200 [==============================] - 2s 100us/step - loss: 0.4348 - acc: 0.8170 - val_loss: 0.4419 - val_acc: 0.8158\n",
      "Epoch 30/100\n",
      "19200/19200 [==============================] - 2s 100us/step - loss: 0.4338 - acc: 0.8173 - val_loss: 0.4513 - val_acc: 0.8144\n",
      "Epoch 31/100\n",
      "19200/19200 [==============================] - 2s 104us/step - loss: 0.4329 - acc: 0.8185 - val_loss: 0.4449 - val_acc: 0.8150\n",
      "Epoch 32/100\n",
      "19200/19200 [==============================] - 2s 99us/step - loss: 0.4333 - acc: 0.8194 - val_loss: 0.4431 - val_acc: 0.8144\n",
      "Epoch 33/100\n",
      "19200/19200 [==============================] - 2s 103us/step - loss: 0.4329 - acc: 0.8203 - val_loss: 0.4402 - val_acc: 0.8158\n",
      "Epoch 34/100\n",
      "19200/19200 [==============================] - 2s 109us/step - loss: 0.4333 - acc: 0.8196 - val_loss: 0.4402 - val_acc: 0.8160\n",
      "Epoch 35/100\n",
      "19200/19200 [==============================] - 2s 101us/step - loss: 0.4329 - acc: 0.8207 - val_loss: 0.4455 - val_acc: 0.8133\n",
      "Epoch 36/100\n",
      "19200/19200 [==============================] - 2s 105us/step - loss: 0.4318 - acc: 0.8178 - val_loss: 0.4440 - val_acc: 0.8140\n",
      "Epoch 37/100\n",
      "19200/19200 [==============================] - 2s 115us/step - loss: 0.4313 - acc: 0.8192 - val_loss: 0.4488 - val_acc: 0.8117\n",
      "Epoch 38/100\n",
      "19200/19200 [==============================] - 2s 104us/step - loss: 0.4315 - acc: 0.8179 - val_loss: 0.4425 - val_acc: 0.8144\n",
      "Epoch 39/100\n",
      "19200/19200 [==============================] - 2s 113us/step - loss: 0.4310 - acc: 0.8208 - val_loss: 0.4420 - val_acc: 0.8152\n",
      "Epoch 40/100\n",
      "19200/19200 [==============================] - 2s 123us/step - loss: 0.4309 - acc: 0.8217 - val_loss: 0.4449 - val_acc: 0.8148\n",
      "Epoch 41/100\n",
      "19200/19200 [==============================] - 3s 167us/step - loss: 0.4325 - acc: 0.8185 - val_loss: 0.4436 - val_acc: 0.8150\n",
      "Epoch 42/100\n",
      "19200/19200 [==============================] - 2s 120us/step - loss: 0.4312 - acc: 0.8200 - val_loss: 0.4425 - val_acc: 0.8154\n",
      "Epoch 43/100\n",
      "19200/19200 [==============================] - 2s 113us/step - loss: 0.4318 - acc: 0.8195 - val_loss: 0.4448 - val_acc: 0.8133\n",
      "Epoch 44/100\n",
      "19200/19200 [==============================] - 2s 120us/step - loss: 0.4317 - acc: 0.8194 - val_loss: 0.4430 - val_acc: 0.8144\n",
      "Epoch 45/100\n",
      "19200/19200 [==============================] - 2s 126us/step - loss: 0.4297 - acc: 0.8203 - val_loss: 0.4418 - val_acc: 0.8148\n",
      "Epoch 46/100\n",
      "19200/19200 [==============================] - 3s 135us/step - loss: 0.4291 - acc: 0.8176 - val_loss: 0.4426 - val_acc: 0.8142\n",
      "Epoch 47/100\n",
      "19200/19200 [==============================] - 2s 126us/step - loss: 0.4305 - acc: 0.8190 - val_loss: 0.4412 - val_acc: 0.8108\n",
      "Epoch 48/100\n",
      "19200/19200 [==============================] - 3s 135us/step - loss: 0.4282 - acc: 0.8200 - val_loss: 0.4424 - val_acc: 0.8163\n",
      "Epoch 49/100\n",
      "19200/19200 [==============================] - 3s 135us/step - loss: 0.4288 - acc: 0.8214 - val_loss: 0.4414 - val_acc: 0.8125\n",
      "Epoch 50/100\n",
      "19200/19200 [==============================] - 3s 143us/step - loss: 0.4327 - acc: 0.8205 - val_loss: 0.4409 - val_acc: 0.8152\n",
      "Epoch 51/100\n",
      "19200/19200 [==============================] - 3s 138us/step - loss: 0.4283 - acc: 0.8215 - val_loss: 0.4428 - val_acc: 0.8137\n",
      "Epoch 52/100\n",
      "19200/19200 [==============================] - 3s 145us/step - loss: 0.4298 - acc: 0.8210 - val_loss: 0.4421 - val_acc: 0.8125\n",
      "Epoch 53/100\n",
      "19200/19200 [==============================] - 3s 149us/step - loss: 0.4291 - acc: 0.8202 - val_loss: 0.4420 - val_acc: 0.8133\n",
      "Epoch 54/100\n",
      "19200/19200 [==============================] - 3s 138us/step - loss: 0.4287 - acc: 0.8217 - val_loss: 0.4444 - val_acc: 0.8117\n",
      "Epoch 55/100\n",
      "19200/19200 [==============================] - 3s 135us/step - loss: 0.4287 - acc: 0.8183 - val_loss: 0.4435 - val_acc: 0.8154\n",
      "Epoch 56/100\n",
      "19200/19200 [==============================] - 3s 141us/step - loss: 0.4282 - acc: 0.8204 - val_loss: 0.4423 - val_acc: 0.8146\n",
      "Epoch 57/100\n",
      "19200/19200 [==============================] - 3s 134us/step - loss: 0.4299 - acc: 0.8196 - val_loss: 0.4444 - val_acc: 0.8144\n",
      "Epoch 58/100\n",
      "19200/19200 [==============================] - 2s 128us/step - loss: 0.4276 - acc: 0.8225 - val_loss: 0.4454 - val_acc: 0.8135\n",
      "Epoch 59/100\n",
      "19200/19200 [==============================] - 2s 118us/step - loss: 0.4253 - acc: 0.8226 - val_loss: 0.4412 - val_acc: 0.8152\n",
      "Epoch 60/100\n",
      "19200/19200 [==============================] - 2s 117us/step - loss: 0.4257 - acc: 0.8221 - val_loss: 0.4421 - val_acc: 0.8127\n",
      "Epoch 61/100\n",
      "19200/19200 [==============================] - 2s 125us/step - loss: 0.4267 - acc: 0.8220 - val_loss: 0.4452 - val_acc: 0.8121\n",
      "Epoch 62/100\n",
      "19200/19200 [==============================] - 2s 123us/step - loss: 0.4267 - acc: 0.8211 - val_loss: 0.4435 - val_acc: 0.8131\n",
      "Epoch 63/100\n",
      "19200/19200 [==============================] - 2s 122us/step - loss: 0.4261 - acc: 0.8210 - val_loss: 0.4418 - val_acc: 0.8140\n",
      "Epoch 64/100\n",
      "19200/19200 [==============================] - 2s 130us/step - loss: 0.4248 - acc: 0.8220 - val_loss: 0.4438 - val_acc: 0.8127\n",
      "Epoch 65/100\n",
      "19200/19200 [==============================] - 2s 122us/step - loss: 0.4258 - acc: 0.8207 - val_loss: 0.4427 - val_acc: 0.8140\n",
      "Epoch 66/100\n",
      "19200/19200 [==============================] - 2s 118us/step - loss: 0.4260 - acc: 0.8216 - val_loss: 0.4431 - val_acc: 0.8146\n",
      "Epoch 67/100\n",
      "19200/19200 [==============================] - 2s 129us/step - loss: 0.4243 - acc: 0.8221 - val_loss: 0.4409 - val_acc: 0.8154\n",
      "Epoch 68/100\n",
      "19200/19200 [==============================] - 2s 117us/step - loss: 0.4276 - acc: 0.8203 - val_loss: 0.4401 - val_acc: 0.8150\n",
      "Epoch 69/100\n",
      "19200/19200 [==============================] - 2s 114us/step - loss: 0.4272 - acc: 0.8189 - val_loss: 0.4433 - val_acc: 0.8133\n",
      "Epoch 70/100\n",
      "19200/19200 [==============================] - 2s 113us/step - loss: 0.4248 - acc: 0.8227 - val_loss: 0.4427 - val_acc: 0.8146\n",
      "Epoch 71/100\n",
      "19200/19200 [==============================] - 2s 107us/step - loss: 0.4255 - acc: 0.8222 - val_loss: 0.4423 - val_acc: 0.8146\n",
      "Epoch 72/100\n",
      "19200/19200 [==============================] - 2s 113us/step - loss: 0.4257 - acc: 0.8219 - val_loss: 0.4440 - val_acc: 0.8125\n",
      "Epoch 73/100\n",
      "19200/19200 [==============================] - 2s 108us/step - loss: 0.4267 - acc: 0.8210 - val_loss: 0.4445 - val_acc: 0.8140\n",
      "Epoch 74/100\n",
      "19200/19200 [==============================] - 2s 120us/step - loss: 0.4246 - acc: 0.8216 - val_loss: 0.4460 - val_acc: 0.8123\n",
      "Epoch 75/100\n",
      "19200/19200 [==============================] - 2s 115us/step - loss: 0.4251 - acc: 0.8208 - val_loss: 0.4453 - val_acc: 0.8094\n",
      "Epoch 76/100\n",
      "19200/19200 [==============================] - 3s 138us/step - loss: 0.4239 - acc: 0.8212 - val_loss: 0.4437 - val_acc: 0.8144\n",
      "Epoch 77/100\n",
      "19200/19200 [==============================] - 2s 119us/step - loss: 0.4254 - acc: 0.8196 - val_loss: 0.4407 - val_acc: 0.8160\n",
      "Epoch 78/100\n",
      "19200/19200 [==============================] - 2s 120us/step - loss: 0.4240 - acc: 0.8231 - val_loss: 0.4445 - val_acc: 0.8160\n",
      "Epoch 79/100\n",
      "19200/19200 [==============================] - 2s 114us/step - loss: 0.4242 - acc: 0.8242 - val_loss: 0.4476 - val_acc: 0.8158\n",
      "Epoch 80/100\n",
      "19200/19200 [==============================] - 2s 110us/step - loss: 0.4246 - acc: 0.8227 - val_loss: 0.4441 - val_acc: 0.8133\n",
      "Epoch 81/100\n",
      "19200/19200 [==============================] - 2s 109us/step - loss: 0.4248 - acc: 0.8209 - val_loss: 0.4455 - val_acc: 0.8150\n",
      "Epoch 82/100\n",
      "19200/19200 [==============================] - 2s 104us/step - loss: 0.4244 - acc: 0.8241 - val_loss: 0.4423 - val_acc: 0.8140\n",
      "Epoch 83/100\n",
      "19200/19200 [==============================] - 2s 103us/step - loss: 0.4238 - acc: 0.8225 - val_loss: 0.4433 - val_acc: 0.8144\n",
      "Epoch 84/100\n",
      "19200/19200 [==============================] - 2s 103us/step - loss: 0.4254 - acc: 0.8217 - val_loss: 0.4444 - val_acc: 0.8137\n",
      "Epoch 85/100\n",
      "19200/19200 [==============================] - 2s 105us/step - loss: 0.4215 - acc: 0.8240 - val_loss: 0.4450 - val_acc: 0.8121\n",
      "Epoch 86/100\n",
      "19200/19200 [==============================] - 2s 111us/step - loss: 0.4232 - acc: 0.8230 - val_loss: 0.4462 - val_acc: 0.8125\n",
      "Epoch 87/100\n",
      "19200/19200 [==============================] - 2s 107us/step - loss: 0.4245 - acc: 0.8223 - val_loss: 0.4433 - val_acc: 0.8148\n",
      "Epoch 88/100\n",
      "19200/19200 [==============================] - 2s 112us/step - loss: 0.4213 - acc: 0.8239 - val_loss: 0.4396 - val_acc: 0.8152\n",
      "Epoch 89/100\n",
      "19200/19200 [==============================] - 2s 105us/step - loss: 0.4218 - acc: 0.8253 - val_loss: 0.4433 - val_acc: 0.8154\n",
      "Epoch 90/100\n",
      "19200/19200 [==============================] - 2s 107us/step - loss: 0.4248 - acc: 0.8224 - val_loss: 0.4433 - val_acc: 0.8131\n",
      "Epoch 91/100\n",
      "19200/19200 [==============================] - 2s 116us/step - loss: 0.4232 - acc: 0.8220 - val_loss: 0.4452 - val_acc: 0.8140\n",
      "Epoch 92/100\n",
      "19200/19200 [==============================] - 2s 108us/step - loss: 0.4220 - acc: 0.8250 - val_loss: 0.4423 - val_acc: 0.8137\n",
      "Epoch 93/100\n",
      "19200/19200 [==============================] - 2s 112us/step - loss: 0.4221 - acc: 0.8221 - val_loss: 0.4456 - val_acc: 0.8150\n",
      "Epoch 94/100\n",
      "19200/19200 [==============================] - 2s 108us/step - loss: 0.4235 - acc: 0.8233 - val_loss: 0.4461 - val_acc: 0.8160\n",
      "Epoch 95/100\n",
      "19200/19200 [==============================] - 2s 113us/step - loss: 0.4205 - acc: 0.8245 - val_loss: 0.4459 - val_acc: 0.8150\n",
      "Epoch 96/100\n",
      "19200/19200 [==============================] - 2s 101us/step - loss: 0.4220 - acc: 0.8227 - val_loss: 0.4424 - val_acc: 0.8148\n",
      "Epoch 97/100\n",
      "19200/19200 [==============================] - 2s 101us/step - loss: 0.4216 - acc: 0.8226 - val_loss: 0.4421 - val_acc: 0.8127\n",
      "Epoch 98/100\n",
      "19200/19200 [==============================] - 2s 103us/step - loss: 0.4221 - acc: 0.8229 - val_loss: 0.4446 - val_acc: 0.8127\n",
      "Epoch 99/100\n",
      "19200/19200 [==============================] - 2s 102us/step - loss: 0.4212 - acc: 0.8226 - val_loss: 0.4437 - val_acc: 0.8133\n",
      "Epoch 100/100\n",
      "19200/19200 [==============================] - 2s 101us/step - loss: 0.4213 - acc: 0.8244 - val_loss: 0.4473 - val_acc: 0.8140\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x18a771e1a58>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from keras.callbacks import History \n",
    "\n",
    "callback_history = History()\n",
    "\n",
    "model.fit(\n",
    "    train_scaled_x, train_y,\n",
    "    validation_split=0.2,\n",
    "    epochs=100, \n",
    "    callbacks=[callback_history]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measuring the performance of our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6000/6000 [==============================] - 0s 37us/step\n",
      "Test loss: 0.428537715912\n",
      "Test accuracy: 0.827\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_acc = model.evaluate(test_scaled_x, test_y)\n",
    "print('Test loss:', test_loss)\n",
    "print('Test accuracy:', test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running risk metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = model.predict(test_scaled_x)\n",
    "pred_values = predictions.round().ravel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "matrix = confusion_matrix(test_y, pred_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "flags = ['No', 'Yes']\n",
    "plt.subplots(figsize=(12,8))\n",
    "sns.heatmap(matrix.T, square=True, annot=True, fmt='g', cbar=True, \n",
    "    cmap=plt.cm.Blues, xticklabels=flags, yticklabels=flags)\n",
    "plt.xlabel('Actual')\n",
    "plt.ylabel('Predicted')\n",
    "plt.title('Credit card payment default prediction');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 0.827\n",
      "precision_score: 0.669281045752\n",
      "recall_score: 0.394757131843\n",
      "f1_score: 0.496605237633\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import (\n",
    "    accuracy_score, precision_score, recall_score, f1_score\n",
    ")\n",
    "actual, predicted = test_y, pred_values\n",
    "print('accuracy_score:', accuracy_score(actual, predicted))\n",
    "print('precision_score:', precision_score(actual, predicted))\n",
    "print('recall_score:', recall_score(actual, predicted))\n",
    "print('f1_score:', f1_score(actual, predicted))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Displaying recorded events in Keras History"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_acc = callback_history.history['acc']\n",
    "val_acc = callback_history.history['val_acc']\n",
    "train_loss = callback_history.history['loss']\n",
    "val_loss = callback_history.history['val_loss']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "epochs = range(1, len(train_acc)+1)\n",
    "\n",
    "plt.figure(figsize=(12,6))\n",
    "plt.plot(epochs, train_loss, label='Training')\n",
    "plt.plot(epochs, val_loss, '--', label='Validation')\n",
    "plt.title('Training and validation loss')\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('loss')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtoAAAGDCAYAAAAVh7eRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XdcllUbwPHfYcsWZIioOEFBQMSJe2uapmburLQy22X59rbX2zQtzVJLzdIyzZ2aMxUnqKCgyBQBmSp7P+f940FDZQsyOt/Pp0/y3Oc+93luQa77PNe5jpBSoiiKoiiKoihK9dKp7QEoiqIoiqIoSkOkAm1FURRFURRFqQEq0FYURVEURVGUGqACbUVRFEVRFEWpASrQVhRFURRFUZQaoAJtRVEURVEURakBKtBWFKXeE0LoCiEyhBAtqrNtbRJCtBVCVHv9VSHEYCFEVLGvQ4QQfSrStgrXWiGEeKOq5yuKotR3erU9AEVR/n2EEBnFvjQGcoHCoq+fklL+Upn+pJSFgGl1t/03kFI6V0c/QohZwDQpZf9ifc+qjr4VRVHqKxVoK4py30kpbwW6RTOms6SUe0trL4TQk1IW3I+xKUp51PejoigVpVJHFEWpc4QQHwohfhNCrBNCpAPThBA9hRDHhRA3hBBXhRBfCyH0i9rrCSGkEMKp6Oufi47vFEKkCyGOCSFaVbZt0fERQohLQohUIcQ3QghfIcTMUsZdkTE+JYQIE0JcF0J8XexcXSHEV0KIFCFEODC8jPvzphDi1zteWyKEWFD051lCiAtF7ye8aLa5tL5ihBD9i/5sLIRYUzS2IKBLCdeNKOo3SAjxYNHrnYDFQJ+itJzkYvf23WLnP1303lOEEJuFEE0rcm8qc59vjkcIsVcIcU0IES+EeK3Ydd4quidpQgg/IYRDSWk6QogjN/+ei+7noaLrXAPeFEK0E0IcKHovyUX3zaLY+S2L3mNS0fFFQgijojF3KNauqRAiSwhhXdr7VRSl/lKBtqIoddVDwFrAAvgNKABeAJoAPmgD0afKOH8K8BZgBUQDH1S2rRDCFlgPzCu6biTQrYx+KjLGkWgD2M5oHyAGF70+BxgKeBRdY2IZ11kLjBJCmBSNUw94uOh1gATgAcAcmA18I4RwL6O/m94HmgOti8b56B3HLxW9LwvgI2CtEMJOSnkOeBY4LKU0lVI2ubNjIcTQov4nAM2AOODOFKHS7s2dSr3PRcHuXmAb0BRoDxwsOm9e0fWHA5bALCCnrBtSTC/gAmADfAoI4MOia3REe8/eKhqDHrADCAOc0N7T9VLKHLTfT9OK9TsF2C2lTKngOBRFqUdUoK0oSl11REq5TUqpkVJmSylPSSlPSCkLpJQRwDKgXxnnb5BS+kkp89EGdJ5VaDsKOCul3FJ07CsgubROKjjG/0kpU6WUUWgDwJvXmgh8JaWMKQq6PinjOhHAeWBM0UtDgBtSSr+i49uklBFSaz+wDyhxweMdJgIfSimvSykvo52lLn7d9VLKq0V/J2uBKMC7Av0CTAVWSCnPFgWc84F+QgjHYm1Kuze3Kec+PwhckVIuklLmSinTpJQni47NAt6QUoYWvYezUsprFRx/tJRyqZSysOj78ZKUcp+UMk9KmYj2e+PmGHqifQh4XUqZWdTet+jYamCKEEIUfT0dWFPBMSiKUs+oQFtRlLrqSvEvhBAuQogdRakAaWhnR++aOS0mvtifsyh7AWRpbR2Kj0NKKYGY0jqp4BgrdC3gchnjBe3s9eSiP0+h2OywEGKUEOJEUerEDbQz5WXdq5ualjUGIcRMIURAUfrDDcClgv2C9v3d6k9KmQZcRzu7fVOF/s7Kuc/N0c4kl6Q5EF7B8d7pzu9HeyHEeiFEbNEYVt0xhqiihbe3KQq4C4DeQgg3oAXa2W9FURogFWgrilJX3Vna7nu0s7htpZTmwNtoP76vSVeBWzOuRbOQzUpvfk9jvIo2QLupvPKDvwGDi2aEx1CUNiKEaARsAP4H2EkpLYG/KjiO+NLGIIRoDSxFm+JiXdTvxWL9lleKMA5oWaw/M6AxEFuBcd2prPt8BWhTynmlHcssGpNxsdfs72hz5/v7FG21nE5FY5h5xxhaCiF0SxnHT2jTR6ajTSnJLaWdoij1nAq0FUWpL8yAVCCzaDFZWfnZ1WU74CWEGF2Ud/sC2hzdmhjjeuBFIUSzooVxr5fVWEqZABwBVgIhUsrQokOGgAGQBBQKIUYBgyoxhjeEEJZCW2f82WLHTNEGm0lonzlmoZ3RvikBcCy+KPEO64AnhBDuQghDtA8Ch6WUpX5CUIay7vNWoIUQ4lkhhIEQwlwIcTOvfgXwoRCijdDyFEJYoX3AiEebF64rhHiSYg8FZYwhE0gVQjQHXi127BiQAnwstAtMGwkhfIodX4M2V3wK2qBbUZQGSgXaiqLUF6+gXZyXjnZG87eavmBRMPsIsABt4NQGOIN2JrO6x7gUbS71OeAU2lnp8qwFBvPPIkiklDeAl4BNwDW0Ad32Co7hHbQz61HATooFgVLKQOBr4GRRGxfgRLFz9wChQIIQongKyM3zd6FN8dhUdH4LtHnbVVHqfZZSpqLNWR8PJKJdwHkzd/pzYDPa+5yGNrfbqCglaDbwBtoc/LZ3vLeSvIN20Woq2uB+Y7ExFKDN7++AdnY7Gu3fw83jUWj/nvOklEcr+d4VRalHhPbfF0VRFKU8RakAccAEKeXh2h6PUn8JIX4CIqSU79b2WBRFqTlqwxpFUZQyCCGGo00FyAH+g3Yh28kyT1KUMhTlu48BOtX2WBRFqVkqdURRFKVsvYEItCkFw4GxavGaUlVCiP8BAcDHUsro2h6Poig1S6WOKIqiKIqiKEoNUDPaiqIoiqIoilIDVKCtKIqiKIqiKDWgwSyGbNKkiXRycqrtYSiKoiiKoigNnL+/f7KUsqx9FYAGFGg7OTnh5+dX28NQFEVRFEVRGjghxOWKtFOpI4qiKIqiKIpSA1SgrSiKoiiKoig1QAXaiqIoiqIoilIDGkyOdkny8/OJiYkhJyentofSoBgZGeHo6Ii+vn5tD0VRFEVRFKXOatCBdkxMDGZmZjg5OSGEqO3hNAhSSlJSUoiJiaFVq1a1PRxFURRFUZQ6q0GnjuTk5GBtba2C7GokhMDa2lp9SqAoiqIoilKOBh1oAyrIrgHqniqKoiiKopSvwQfatSklJQVPT088PT2xt7enWbNmt77Oy8urUB+PPfYYISEhZbZZsmQJv/zyS3UMWVEURVEURakmDTpHu7ZZW1tz9uxZAN59911MTU159dVXb2sjpURKiY5Oyc88K1euLPc6c+fOvffBKoqiKIqiKNVKzWjXgrCwMNzc3Hj66afx8vLi6tWrPPnkk3h7e+Pq6sr7779/q23v3r05e/YsBQUFWFpaMn/+fDw8POjZsyeJiYkAvPnmmyxcuPBW+/nz59OtWzecnZ05evQoAJmZmYwfPx4PDw8mT56Mt7f3rYcARVEURVEUpfr9a2a039sWRHBcWrX22dHBnHdGu1bp3ODgYFauXMl3330HwCeffIKVlRUFBQUMGDCACRMm0LFjx9vOSU1NpV+/fnzyySe8/PLL/Pjjj8yfP/+uvqWUnDx5kq1bt/L++++za9cuvvnmG+zt7dm4cSMBAQF4eXlVadyKoiiKoihKxagZ7VrSpk0bunbteuvrdevW4eXlhZeXFxcuXCA4OPiucxo1asSIESMA6NKlC1FRUSX2PW7cuLvaHDlyhEmTJgHg4eGBq2vVHhAURVEURakd1zPzuJFVsTVeSt3wr5nRrurMc00xMTG59efQ0FAWLVrEyZMnsbS0ZNq0aSWWzzMwMLj1Z11dXQoKCkrs29DQ8K42UsrqHL6iKIqiKPdRckYuIxcdpoWVMRvm9Krt4SgVpGa064C0tDTMzMwwNzfn6tWr7N69u9qv0bt3b9avXw/AuXPnSpwxVxRFURSl7tFoJC+vDyAxPRe/y9eJTM68p/4S0nJ4Z8t5svMKq2mESmlUoF0HeHl50bFjR9zc3Jg9ezY+Pj7Vfo3nnnuO2NhY3N3d+fLLL3Fzc8PCwqLar6MoiqIoSvVadjiCQ5eSeH5gW4SALWdj76m/Nccus/rYZXaev1pNI1RKIxpKSoG3t7f08/O77bULFy7QoUOHWhpR3VJQUEBBQQFGRkaEhoYydOhQQkND0dOrWvaQureKoiiKUvP8L19n4vfHGO5qz+IpnZmy/ATxaTnsf6VflTaQk1Iy6Mu/iUjOZICzDSsf61YDo274hBD+Ukrv8tqpGe1/iYyMDHx8fPDw8GD8+PF8//33VQ6yFUVRFEWpealZ+Ty/7gwOlkb8b3wnhBCM7exAZHImgTGpVerzYnw6EcmZOFgYcTg0meuZVV9cWVCo4c3N59h0JqbKfdwL/8vX6/waNBVo/0tYWlri7+9PQEAAgYGBDB06tLaHpCiKoihKKaSUvLYxgIS0HL6Z7IW5kT4Aw92aYqCrw6YzVUsf2XnuKjoCPh7XiQKNZFdQfJXH+NnuEH4+Hs1bm4NIzsitcj9VERhzg/FLj7Lm+OX7et3KUoG2oiiKoij1iv/la0xYepRLCen33FdSei6p2fnVMKrq9dOxy+wOSmD+CBc8m1veet2ikT4DXWzZHhhHQaGmUn1KKdlx7irdWlnRr70NrZuYsC0grkrj23I2lmWHIhjmakd2fiGL9oZWqZ+qkFLy0Y4LWJsY8FDnZvftulWhAm1FURRFUeqNiKQMZq32w+/ydV7bEEihpuqpA1JKpiw/ztQVxysdtN4pMT2HxftDycorufRuZZyPTeWjHRcY6GLLE71b3XV8bGcHkjPy8A1PqVS/lxIyCE/K5IFOTRFCMMrDgWMRKSSm3V1SuCxBcam8vjGQrk6N+WayF5O7NWftyWjCkzIq1U9V7b+YyInIa7w4uB1mRTP9dZUKtBVFURRFqRdSMnKZufIUQgheGdKes1du8NOxqCr3F5aYQWhiBudj01h97N5SEBbtDeWLvy4xa7UfOflVL5uXk1/I8+vOYGViwBcPe5S44LG/sy1mRnpsqWT6yI5zVxEChrnZAzDavSlSwp/nKl595HpmHk+t8ceykQHfTu2CgZ4OLwxqj5GeDp/tulip8VRFQaGG/+28SOsmJkzq1qLGr3evVKCtKIqiKEqdl51XyBOr/UhIy2HFo948O7At/Z1t+Hx3CDHXs6rU51/BCQB0bmHJgr9CuJqaXaV+UrPy+eN0LM52ZhwNT2HOz/7kFVRthvzrfaFEJGfy5UQPrEwMSmxjpK/LA52asjsovlK1sP88d5VuTlbYmhkB0M7ODBd7M7YFVizQLijU8Oy60ySm5/Ld9C7YmGk3yLMxM+Spfm3YHZSAX9S1Co+nKn73jyEsMYPXhrugr1v3w9i6P8J6rn///ndtQLNw4UKeeeaZUs8xNTUFIC4ujgkTJpTa753lDO+0cOFCsrL++cdn5MiR3Lhxo6JDVxRFUZQ6oVAjefG3MwTE3GDRJE+8WjRGCMGHY90AeHPz+SpVn9gTnICHowWLHulMgUby3taqbeb2u/8VsvML+XKiBx895MaBkCSeX3em0ukowXFpfH8ogonejvi0bVJm2zGezcjMK2TPhYQK9X0pIZ2wxAwecG962+ujPRzwv3yd2BvlP2R8uusivmEpfDjW7ba8cYBZfVpha2bIx39eqLFKIJm5BSzYcwnvlo0Z5mpXI9eobirQrmGTJ0/m119/ve21X3/9lcmTJ5d7roODAxs2bKjyte8MtP/8808sLS3LOENRFEVR6p6Pdlxgd1ACbz3QkeFu/wSKjo2NmTfMmYMhSWyt5KK+hLQczl65wZCOdrSwNub5Qe3YFRTPvgoGrjcVaiQ/HbtMV6fGuDWzYGr3lrw1qiO7guJ55feACueQFxRqmP9HII2N9XljZPn7VHRvZUVTC6MKp4/sCNSmjQx3tb/t9dHuDkXHy75/W87GsvxwJDN6tmSid/O7jhsb6PHK0Pacjr7BzvNVr2RSlhWHI0lKz+U/IztUqYZ4bVCBdg2bMGEC27dvJzdXW/YmKiqKuLg4PD09GTRoEF5eXnTq1IktW7bcdW5UVBRubtqn9ezsbCZNmoS7uzuPPPII2dn/PHnOmTMHb29vXF1deeeddwD4+uuviYuLY8CAAQwYMAAAJycnkpOTAViwYAFubm64ubmxcOHCW9fr0KEDs2fPxtXVlaFDh952HUVRFEW53344EsmPvpE87tOKx0tYGDijpxOezS15b1sw1ypRE3pvUUA9pKM28JzdpzXtbE15e0tQpRY0HriYSPS1LB7t5XTrtSd6t2LeMGe2nI3jv5vOoalAsL3qaBSBMam8+6ArlsYlp4wUp6MjeNDDgb8vJVXofe88f5WuLa2wNTe67fUW1sZ4OFqwLaD09JFzMdrFj92crHhrVMdS203o0pz2dqZ8tutilVNnSpOYnsP3h8IZ2cmeLi0bV2vfNenfFWivfODu/04u1x7Lyyr5+JlftMczU+4+VgHW1tZ069aNXbt2AdrZ7EceeYRGjRqxadMmTp8+zYEDB3jllVfK/Khl6dKlGBsbExgYyH//+1/8/f1vHfvoo4/w8/MjMDCQv//+m8DAQJ5//nkcHBw4cOAABw4cuK0vf39/Vq5cyYkTJzh+/DjLly/nzJkzAISGhjJ37lyCgoKwtLRk48aNFb27iqIoilKtjkek8OGOYIa52vHfB0qe5dXVEXw63p207Hw+3F7x1I89wQm0tDamvZ02XdNAT4ePx3Ui9kY2i/ZVvFTd6mNR2JsbMeyOmeK5A9ry3MC2/HrqCu9tCyrzd3x0ShZf/BXC4A62PNCpaant7jTGsxkFGlnubHRYYjqXEjIY2cm+xOOjPRw4F5tKZHLmXccS0nKY9dMprE0M+XaaV5l50bo6gv+M6EBUShZrT1RvfeuFe0PJK9Awb5hLtfZb0/5dgXYtKZ4+cjNtRErJG2+8gbu7O4MHDyY2NpaEhNI/rjp06BDTpk0DwN3dHXd391vH1q9fj5eXF507dyYoKIjg4LL/oTly5AgPPfQQJiYmmJqaMm7cOA4fPgxAq1at8PT0BKBLly5ERUXdy1tXFEVRlCrb6B+DmaEeCx/pjK5O6akCzvZmPNO/DX+cieXvS0nl9puRW8DRsBSGdLC7LQWhq5MVj3g354fDkVyMTyu3n7DEdA6HJjOtR4sSA9CXh7Rndp9WrD52makrThBRQvk7KSX/3XwOPR0dPhjrVqmUiA5NzWhvZ8rms2UH2jsC4xECRpQSxN/M295+R/pNdl4hs3/yIyOngBWPetPE1LDcMfV3tqFna2sW7QslLadi9cmvXMvit1PRfLE7hAMXE8nIvf0ThbDEdH47dYVpPVrSqolJhfqsK/5de3A/tqP0YwbGZR83sS77eBnGjh3Lyy+/zOnTp8nOzsbLy4tVq1aRlJSEv78/+vr6ODk5kZNTdh3Lkn74IiMj+eKLLzh16hSNGzdm5syZ5fZT1lO1oeE/P0S6uroqdURRFKWeSs3OJyEth/Z2ZrU9lCrRaCQHQpLo296GRga65bafO7AtO85d5Y0/zvHXS30xMSw9xPk7JIm8Qg1DOt69oG7+CBf2XEjgjT/OseHpXuiUEeCvPnoZA12dUsvMCSF4Y2QHnJqY8MnOiwxfeJi5A9rydP/WGOpp39Mfp2M5HJrMB2NcaWrRqNz3eWf/Yzyb8fnuEK5cy6K5lXGJ7f48dxXvlo2xuyNt5KamFo3o5mTFtsA4nhvUDtDe/1d/D+BcbCrLp3vToal5hcf0xsgOjF58hOfWnqFHa2vsLQyxMzfCztwIe3MjsvIKORqezLHwFHzDk7lyLbvoXJAS9HQEHs0t6dXGml5tmvDDkQiM9XV5bmDbSt2fuuDfFWjXElNTU/r378/jjz9+axFkamoqtra26Ovrc+DAAS5fLvsjlr59+/LLL78wYMAAzp8/T2BgIABpaWmYmJhgYWFBQkICO3fupH///gCYmZmRnp5OkyZN7upr5syZzJ8/HyklmzZtYs2aNdX/xhVFUWpATn4he4ITiLuRTXxaDolpucSn5RCfmkNmXgHjvRyZ079NhWbfGrIPtgezwT8Gd0cLpvVoyYMeDhjplx+w1hVBcWkkZ+Qy0MW2Qu0N9XT5ZLw7D393jCUHwnhteOkpBnuC47EyMSgx17exiQH/HdmBV34PYN2paKZ2b1liH2k5+Ww8HcNoD4cyv9eEEEzt3pIhHex4f3swX+29xJaAWD4a24l2dqZ8sCOYLi0bl3qd8ozxdODz3SFsORvLswPb3XU8LDGDkIR03hldem41wGiPpry1JYiQ+HSc7c1YtC9U++Ay0oXBJTyQlKWTowVz+rfh52OXy/yEwdxIjx6trXnCpxU+bZvQ3MoY/8vXORqejG9YCksOhPHN/jAA5g1zxroe/kyrQPs+mTx5MuPGjbuVQjJ16lRGjx6Nt7c3np6euLiUnXM0Z84cHnvsMdzd3fH09KRbt24AeHh40LlzZ1xdXWndujU+Pj63znnyyScZMWIETZs2vS1P28vLi5kzZ97qY9asWXTu3FmliSiKUi/8dCyKj//UboxhYqCLnYV2lqxbKyvyCjWs9I1k3cloHvdpxey+rbFoVLd3jqsJUkoOhiTRsak52XmFvLYhkI92XGCityNTu7fEqR58/L7/YiJCQL/2NhU+p6uTFQ91bsaKI5FM7taixBne/EIN+y8mMtTVHr1S8o3HeTVjg38M724NQl9Hh4ld766yscEvhqy8QmYWWwRZFltzIxZP8WJCl0Te2nKeycuP49i4EVm5hXwyrlOZM+dlcWxsTDcnK1YcicRQT5fJ3VtgWmw2/+ZmNCPcys79HtGpKe9sDWJbQBwhCdpA++Eujszu07pK43p9uAuvD3chM7eAhLSc2x6KBdCjtTVuzSzuSgnyadsEn7ZNmDdM+zBzMuIaEckZzOjpVKVx1DZRU7UO7zdvb295Z13pCxcu0KFD+SVylMpT91ZRlNoy6pvD6AjB2tk9bgsobgpPyuCrPZfYHngVcyM9nurXhpm9nMpMJahL8go0GOjd2xKqkPh0hi08xGcT3Hm4iyPHI67x8/HL7A6Kp0Aj6dvehvFezRja0b5CaRm1YewSXwA2z/Upp+Xt4m5kM/DLgwzuYMfiKV53HfcNS2bqihMsm96Foa4lLw4E7SY0c9ee5khYMrP7tGL+iA63gkKNRjLwy4NYmRjwxzOVGx9oc5+/3h/K8kMRvDSkPXMH3FtKREh8Ou9tC+JoeArmRno82suJmb2csDY1ZPjCQ5ga6rFhTq9y+5m24gQX49NJz8nHw9GSNbO63UpxUW4nhPCXUnqX165+/KujKIqiKEBEkna77Dcf6FBikA3QxsaUxVO8eKZ/Ggv2hPD57hB+PBJJ5xaNsTM3xN7cCDuLf/JF29maVnk28SYpJdn5hRgbVP3XalJ6LksOhLH2RDSvDXdmVhVnEgEOh2o/ru/dtglCCHq2saZnG2sS0nJYdzKa9aeu8MKvZzE11GOEmz0PeTWjRyvre74P1SUlI5eAmBu8OKh9pc91sGzEk31a8/X+MB7zuX5Xesie4ASM9HXo067smXILY31WPdaVD7YHs/xwJOFJmSya5ImZkT5/X0oiKiWLl4c6V3p8AI0MdHl9uAvPDmhbLQ+AzvZmrJ3dg7NXbvDdwXAWHwhj+eEIRnZqysX49DJL8hU32qMpR8KSaW7ViKXTvFSQXQ1UoK0oiqLUG9uLNt0YVbTJRlk6Opiz4tGunI6+zorDEUQkZeJ/+RrXs26vhNC9lRXLpntjYVy1FJO8Ag0v/HqGI6HJbJjTC2f7yi0+TM3K5/tD4az0jSKvUIO9uREL94byUOdmVc5J9Q1LprWNCQ6Wty+uszM34sXB7Xl+YDtORF7jj9Mx7Dwfz+/+MThYGDHOy5G5A9rW+iz3wZAkpKTC+dl3eqpfG349dYUPtgfzx5x/FjRKKfkrKJ7ebSu2wFJPV4f3xrjRzs6Md7YGMX7pUVbM6MrKo1HYmhkywq30GfGKqO5PWTybW/Ld9C6EJWaw7FA4m87EoiOo8DhHuTsQHJfG9J4t62U+dF2kAm1FUf61EtNzsDE1rDc7jNUXiWk5WBob3HP6w52klGwNiKOrkxX2FiVXTyiJV4vGfDu1y62vc/ILSUrPJSEth4CYVD7ZeYGHvz/Kyse60cyyclUf8go0zF17mj3BCZgZ6vHkGj+2zu1doaA9I7eAlUciWXY4gozcAh70cODFwe0p1GgYtvAw3+wP490HXSs1nptjOhF5jQldHEtto6Pzzyz3+2Pc2HMhgT9Ox7DkYBi+4cn88GhXrEzK3zSlphwISaSJqSGuDhWrdHEnE0M95g1zZt6GQLYFxjHGsxmgXWAZl5rDi0MqN1M+rUdLWjcxYc4vp3lwyRFuZOXz8pD2ZdaUrk1tbU35bIIHLw1pT3xqzl0PXKUxMdTjvTFuNTy6f5e6+R1SjRpKDnpdou6p0hD8dCyK7h/vY9XRqNoeSoMSlphB388PsGjfpWrvOyQhnbDEDEZ7lD+bXRYjfV2aWxnj7WTFE71bsfrxblxNzWHct74Ex5VfO/mm3IJCnvnFnz3BCbw7uiOrHu9G3I1snvv1TLnbbh+PSKH/5wf4cs8lerS2ZucLfVg0qTOtmpjQ1taMR7o25+fjl0vcQKQ8Z6Kvk5VXiE/bJuU3RpvG8KCHA6se68bSqV0Ijktj/NKjXE4p+9qp2fksORDGmejrlR5jWQoKNRy6lMQAZ5t7SmUZ7+WIq4M5n+68SE5+IaBNG9ERMKgKM+W92jZh81wfrEwMMNTTYXIpJf3qkqYWjejcov7sotgQNehA28jIiJSUFBUYViMpJSkpKRgZVXw2SVHqEo1G8r+dF3h7SxAC2FLORg/1VVJ6LvGpZdfUL2710Sj6fX6AL/8KIe5G1ern5xdqeHn9WXLyNew8H1+lPsqyLSAOXR1xzx/X36lXmyb8/nRPBIKJ3x/DNyy53HNy8guZ8/Np9l5I5IMxrsz0aUWXlo15f4wbhy4l8cVfIaWeuy0gjhk/nMSikT6b5/qwfIZiTnApAAAgAElEQVQ3Lva3z9y+OLgdBno6fLbrYqXfj29YMjoCeraxrvS5w93sWTu7O9ez8hj37VECrty4q01BoYafj19mwBcH+Xx3CBOKyumV93BRUaejb5CWU8CAKqaN3KSjI3hrVEfiUnNYcTgCgL+CE+jSsnGV0yJaNTFh+3O92fNSP2zMVGqFUr4GnTri6OhITEwMSUnl7xKlVJyRkRGOjqV/JKkodVVugbbM2ZazcUzr0QJbMyMW7LnE1dTsSm8UUZfdyMpj7BJfUrPz+W5aF3q3K3tmc8XhCD7ccQEna2MWHwjj24PhDO5gy4yeTvRqY13h1JpvD4QTGJNKn3ZNOByaTGRyZrXt4ialZHvgVXq1sa6R+tgu9uZsmtuLmT+e4tEfT/L5w+481Lnkf+dy8gt5ao0/f19K4uOHOjGl+z8zm5O7teBcbCpLD4bj5mBxa8e9m+/hhyORfLjjAt2crFg2owuWxiWnZ9iaGfFk39Ys3BuK/+W7F/SV5XBYMh7NLTE3qlrOeZeWVmyc04uZK08yadlxlkztzEAXbR1l37Bk3t8WTEhCOt1bWfHKUGfWHL/M57tD8A1L5qtHPEvdFEVKycX4dBrp65ZZXnD/xUT0dES537cV0aO1NcNc7fj2YDg92zThwtU0/jvy3ipmGRvo0cK6QYdPSjVq0OX9FEVRbkrNzufpNf4ci0jhteHOzOnXhojkTAZ9+TfvPejKoxWshVvXSSl5ao0/+y8m0sLamOiULD6b4M44r5KDxmWHwvn4z4uM7GTPokmdiU/N4ZcT0fx2KprrWfm0tjFhRo+WTO3Rssx81HMxqTz0rS8PuDfl1aHO9PnsAG8+0OGeKmcUFxhzgwcX+/LZePcSaxpXl7ScfJ76Sft9MtzVnhbWxtiaGWJfVKvb2tSQt7ec50hYMv97qFOJOwLmFWiYvPw4wXFpbJrbCxd7cwo1kg93BLPSN4qRnexZMNGz3M1jMnML6P/FQVpYGbPh6Z4VeuBJy8nH872/mDugLa9UsSLGTUnpuTy+6hTBV9N4dagz/pevs/dCAs2tGvHfkR0Y5mqPEAIpJb/7xfDO1iAaGejyxcPutwJzgPjUHDafjWXT6VhCEtKxMjFg78v9Ss0BH77wEI2NDVj3ZI97Gv9NUcmZDPnqb8yN9EnJzOPgq/3rRR1xpW6raHm/Bp06oiiKAtq6uhO/O8apqGssmOjBM/3bIoSgjY0p7WxN2VUDaQ615adjl/krOIHXh7uwea4P3VpZ8fL6AJYcCLsrjW7pQW2Q/YB7UxZN6oy+rg7NrYyZP8KFY/8ZxIKJHpgb6fPutmBmrjxJ6h3VOm7KyS/kpfVnsTY14P0H3WhuZYyznRn7LiRW2/vaFhCHvq5gWBl1j6uDuZE+qx7vyvQeLQm+msaqo1F8uOMCz649w4TvjjHgi4McCUvm0/HupW67baCnw9KpXpgZ6fHkT/4kpOXw7NrTrPSN4nGfViye7FWhHRpNDPV4aXB7/C9fZ3dQQoXGfzw8BY3UlvW7VzZmhvz6ZA/6tGvCp7suciw8mdeHu7DnpX4Md2t6K/AXQjCxa3O2PdcbO3MjHl/lx3vbgtjoH8PUFcfp+ck+Ptl5ERNDXV4d2p607Hw+3BFc4jVjb2RzMT6dAS4V36SmPE5NTHi0pxMpmXm0szVVQbZyX6nPPhRFqVUFhRok1Njq/ZSMXMYvPUp6TgGrHut218fRw93sWXIgjGuZebVaZaE6nI9N5aMdFxjoYssTvVuhoyNY9Vg3XtsQwOe7tbnX7z3oip6uDksOhPH57hAe9HBgwUSPu3bIM9LXZZyXI+O8HPnd7wpvbDrH2G99WfGoN21sTG9r+8XuEMISM/jp8W63qm0M6mDLskMRpGbn3/POjBqNNm2kX3ubKpfgqwxDPV0+GKutvCCl5EZWPgnp2i3eE9JycLI2oXvrsvOfbc2NWDqtC5OWHaP/5wfJKSis0gz/RG9HfvSN5NNdFxnUwbbcn5MjYck00tettgVwJoZ6rJjhrU3baWuNrVnp63Pa2pqy6ZlefLrrIit9owBobtWI5wa246HOzW6lEeXka1h8IIyxns3oe8eujwcuah/OqlrWrzTPDWrH9sCrjO3crFr7VZTyqBltRVFqTUJaDoMW/M2rvwfU2DU2nYnlamoOa564O8gGGOZqj0bC3uCKzRjWVRm5BTy79jRWJgZ88bDHrWoNBno6LJjoyZz+bfjlRDRP/+zPgj2X+Hx3CGM9Sw6y7/Swd3PWzu5BanY+Dy3xvbUZCmirZ/zgG8n0Hi1vC5oGdbCjQCP5+9K9r5Hxj77O1dSce642UhVCCBqbGOBib05/Z1se6dqi3CD7pi4tG/PRQ53Q1xUsnuxVpTQaPV0d5g93ITI5k19PRpfb/khYMt1bW1VraUU9XR3Gdm5WZpB9k5G+Lu+MdmXzXB82zunJoXkDeHlI+9ty9Z8d2JbWNia8sekcWXkFt51/MCQRx8aN7nqYu1cWjfQ58voAnunfplr7VZTy1GigLYQYLoQIEUKECSHml3C8hRDigBDijBAiUAgxsuj1IUIIfyHEuaL/D6zJcSqKcv+lZuUz44eTXE7J4s9zV0tNS7hX2wLicGtmXuoMn6uDOY6NG7Hz/NUauf79IKXkzU3niL6WxaJJnnfNzOvoCF4f7sIHY1zZfzGRr/eFMs6rGV9O9Cw3yL6pq5MVW+b60NSiETNXnuKnY1Gk5+Tz6u8BtLQy5j8jXW5r79ncEmsTA/ZdKP8BJjO3oMy//20BcRjp6zC4g12pbeqqid7NCXhn6G2LIitrUAdbureyYuHeUNJzSr9PcTeyiUjKrJa0kXvl2dySLi2tSswrN9LX5ZNx7sRcz2bBX/+UgczJL8Q3LIWBLrY1UtteT1dH1cxX7rsaC7SFELrAEmAE0BGYLIS4cw/QN4H1UsrOwCTg26LXk4HRUspOwKPAmpoap6Io1Sczt4DF+0O5cLXsWsTZeYU8sfoUkcmZzB/hQn6hZHdQ9edJRyZnEhCTyhiP0j8uFkIw3NUe37AU0soIYqrTrvNXmbD0KIlpFS+/V5bf/WPYfDaOFwe3L3O2dXpPJ36c2ZV5w5z5fIIHupWsUdzcypiNz/RigLMNb28JYtQ3R4i7kc2XEz3u2npcV0fQ39mWgyFJFBRqSu1TSsms1X70/nQ/f5XwPVBQqOHPc1cZ5GJX7bvo3S/3GtwJIXhjZAdSMvNYvD+s1HZHisoSVke1jprWrZUVU7u34EffyFslBE9EXiM7v5ABztWbNqIotakmZ7S7AWFSyggpZR7wKzDmjjYSuFk81AKIA5BSnpFS3ixuGwQYCSFUwUpFqcNib2Qz4btjfPHXJR5cfITF+0NLDLDyC7U76flHX2fhJE+e6tualtbGbAus/nrW2wLitNt1e5Q9mzjczZ68Qs2t/NCatN7vCs/8chq/y9f53T/mnvsLTUjnnS1B9GpjzdwBbctt39/ZlrkD2lY6yL7J1FCP76d781S/1lxOyeLpfm3o0tKqxLaDO9iSmp2P3+XSNzQ5HnGNYxEp6Ovp8OQafz7bdfG2eszHI66RnJHHqHuYEW4IPJpbMrlbc5YdjuB4REqJbXzDkmliaoizXeW2gK8tr49wwcbMkNc3BpJf9PNnpK9TpfrfilJX1WSg3Qy4UuzrmKLXinsXmCaEiAH+BJ4roZ/xwBkpZW5NDFJRlHvnf/k6Yxb7EnMti28md2aYqz1f/HWJ8UuPEpaYfqudRiN5fUMg+y8m8uFYN0Z20lYuGO3ugG9YMskZ1fdjLqVky9lYujlZlVsj26tFY2zMDMucVddoJE+t8WPM4iMcuJhYpY2wfjwSyWsbAvFp2wTP5pb8cTrmnjbUupaZx5xfTmNsoMvCRzyrHDxXlq6O4D8jOnBo3gDmDSu9hFyf9jYY6OqUmT7y9b5QbMwMOfBqfyZ3a863B8N59MeTpBR9L2wLiMPEQPeeNy9pCN58oCNO1ia8/NvZu1JtNBqJb1gyvdtWvO55bTM30ueDMW5cjE9n2aEI9l9MpFebJhWqyKIo9UVNBtol/aTf+RtlMrBKSukIjATWCCFujUkI4Qp8CjxV4gWEeFII4SeE8FOb0ihK7fjjdAyTlx3HxFCXTXN7MdrDgcVTvFg8pTPR17IY+fURlh0Kp1Aj+fjPC/xxJpZXhrRnaveWt/oY5dEUjYSd56ovTzr4ahrhSZk86Fn+AjodHcHQjnYcuJh0a6vmO/10LIrdQQnEXM/msVWnmPDdMY6FlzyzeCcpJV/tucT724MZ7mrPike9mdS1OeFJ2tSWqkjNymf6Dye4ci2LJVO9sC1lk5Ca1MLauMygztRQj+6trUot83cyUjub/XS/Nlg00ud/49z5dHwnTkZdY/Q3RzgVdY2d568y1NVeBV9oK4AsfMSTxPRc3th87raHtJCEdJIz8iq87XpdMdTVnpGd7PlqzyWir2UxwLn6yvopSl1Qk4F2DFB8VwFHilJDinkCWA8gpTwGGAFNAIQQjsAmYIaUMrykC0gpl0kpvaWU3jY26odTUW4q1Mhq2w65NBqN5NNdF3l5fQBeLS3Z/IwPbW3/+ch6lLsDf73Uj37tbfj4z4sM+vIgK45EMrOXE88OvD3FwdnOjHa2pmwLqL5Ae+vZOPR0BCPdKpZyMNzNnuz8Qg6VUCUjPCmD/+28yEAXW479ZxAfjnUj5noWk5cfZ9qKE5wtYZvqmzQayfvbg1m0L5QJXRxZPKUzhnq6jHRviqGeDhurkD6SkVvAoytPcikhne+nd6FHBatg1IbBHeyISM4kIinjrmPf7A+liakBU4rVo36kaws2Pt0LIQQPf3eMtJwCRpeT+vNv4tHckpeGtGdH4FX+OB176/Wb28bXt0Ab4N0HXTE20D5I9Vf52UoDU5OB9imgnRCilRDCAO1ix613tIkGBgEIITqgDbSThBCWwA7gP1JK3xoco6I0OLuD4un+8T7e3Hyuxq6RmVvAUz/7s/RgOJO7Neenx7vTuIQa1DZmhiyb3oUFEz24lpnHuM7NeHtUx7tmQYUQjPZw4NTla1xNzb7n8Wk0km0BcfRtb1PiuErSo7U15kZ67LojfaSgUMPL6wNoZKDLJ+M6YaCnw7QeLfl73gDefKADwVfTGLvEl4e+9eWFX8/w8Z8X+OFIJDsCr+IXdY3XNgay0jeKx3yc+Gy8+60qH+ZG+gx1tWdbYBy5BSXPopckO6+Qx1ed4lxsKouneNX5wORmPeQ7Z7X9L1/ncGgyT/ZtTSOD22erOzlasP253gxwtqGFlTG926qJlOKe7teG7q2seHvLeS6nZAJwODSZ1jYmOFiWnSZVF9maGfHlRE8e92lFcyvj2h6OolSrGlvCLaUsEEI8C+wGdIEfpZRBQoj3AT8p5VbgFWC5EOIltGklM6WUsui8tsBbQoi3irocKqWs+ZVKilJPpWbl8+62IDadicVIX4eN/rHMG+ZS7ZuwJKXn8sTqU5yPTeXtUR15zMepzPQBIQTjvBwZ7eGAno4ote0o96Ys2HOJHYFXy6w3LKUkLaegzE1Q/C5fJy41h9dHuJTa5k76ujoM7mjH3uAE8gs1tzYGWXownIArN1gy5fb0DCN9XWb1ac2kbi1YeSSSQ6FJnIm+QXxaDnkFty8CfXFwO14Y1O6u9z7eqxnbAuI4cDGR4RWYec/JL+TJNX6cirrGokmda3yXxOpwc5fIvRcSmN33n7/Xb/aHYmVicFsKUXGNTQxY+Vg3CjXyvuWe1xe6OoKvHvFk+MJDvPDrWdbO7s7JyGtM9Has7aFV2ZCOdgzpWP/KNypKeWq0VpKU8k+0ixyLv/Z2sT8HAz4lnPch8GFNjk1RGpKDIYm8vjGQ5Iw8XhjUjiEd7Rj1zRE2+sfcFtzcq4ikDGauPEVieg7fT/eu1C/G8na0a21jilszc7aVE2jP33iObYFx/PFML1zszUtsszUgtkp1l4e72vPH6ViOR6TQp50N52NTWbQvlAc9HEqtg2xqqMdzg9rx3KB2wN07CRob6NGtVclVOXq3bYKNmSEb/GPLDbTzCzU8u/Y0h0OT+WyCOw/WwuYtVTWogy3fH4ogNSsfC2N9zl65wcGQJF4b7lxuyT4VZJfMwbIRH4/rxLNrz/DUGn+y8wvrZdqIojR0amdIpUGTUt76aLUhSs/JZ/7GQGauPIVFI302P+PDS0Pa49bMgi4tG7PuZPQ9VbUozv/ydcYvPUpGbgHrZveokdmn0e4OBFy5QXRKVonHdwfF85vfFXILNMz5+XSJm3fkF2rYEXiVIR3tK113uW97Gxrp67LrfDw5+YW89NtZrE0NeH+Ma4X7uHMnwdKCbNBuoPFQ52YcDEm8VWWjJBqN5KXfzrL3QiIfjHFlonfzUtvWRYM62FGokRy8pP1Q8pt9oVga6zOjp1PtDqyeG+XuwHgvRw6HJqOrI+ihyuIpSp2jAm2lQVtxOJJ+nx9k9dGo2h5KtYu9kc0DXx9hvd8Vnu7Xhm3P9aaTo8Wt41O6tSAiOZPjEdfu+Vp/BcUzZflxzBvps3FOr1J3WbxXN2eNS6qpnZyRyxt/nMPVwZyfHu9G9LUsXtsQeNeDxJGwZK5n5VdpxtdIX5cBLjbsDkrg890hhCZm8NkEDyyNqzf9prjxXo4UaCRbA0qvI77iSATbA6/y+nAXptfD4PSfXSITOR+byr6LiTzh0wrTeroBTV3y3hhXWlob06VlY8yNSk+nUhSldqhAW2mwkjNy+XpfKIZ6Ory3LajEXefqq4S0HKYuP871rDx+e6on80e4YKh3+4KyB9ybYm6kx9qT0fd0rTXHonj6Z39cmpqzcU4vWjUxuaf+yuLYWBswbLsj6JRS8t9N50jPLeCrRzzxaduE14c7s/N8PD8cibyt7dazcVg00qdf+6otoBvmak9yRi4/HIlkavcWVe6nopztzXB1MGfj6ZKrj5yJvs5nu0IY7mrP0/2qLw3oftLVEQxwseVgSCJf7bmEmZEej/o41fawGgRTQz22zPVh2fQutT0URVFKoAJtpcH6as8lsvIL2TinF50cLXn+1zNllmG7XzJyCypcf7kkKRm5TF1xgqT0XFY/3o2uTiWnJhjp6zLOy5Fd56+WmZZQllW+kby1JYgBzrasm92dJqY1v0HrKPemXIxPJzThn41u/jgdy+6gBF4d2p72Rbveze7TmmGudnyy8yJ+UdpZ++y8Qv4KimeEmz0GelX7522giy0Gujq0tDbmjZEd7v0NVcB4L0fOx6YREp9+2+up2fk8t+4MduZGfDrBvd5sRFKSwR1sScspYN/FRB73aaVmX6uRpbFBjX7qoihK1alAW2mQLiWks+5kNNO6t8CtmQU/POqNjZkhs1afKjX/936QUvLir2eYvPw4Sw6EVfr81Kx8pv1wkpjrWfwwsyte5aRwTOnegvxCWepsaVmOhifzwY4LDOlox/fTu2BscH8+5n+gU1OEgG2B2prasTeyeXdrEN2crHii9z8zukIIPn/Yg2aNGzF37WmSM3LZdzGBzLzCCm1SUxozI32+n9GFlTO7VjrHu6oe9NRWZPmj2N+TlJL5GwOJT83hmymdy6yyUh/0bqfdJdLMUI/HfVrV9nAURVHuCxVoKw3ShzsuYGqox4uD2wPQxNSQVY91o0AjmbnqJNcz82plXL/7xbD3QiJtbU35fHfIXWkPZUnPyWfGypOEJ2awbLp3hTYpaW9nhnfLxqw7eaVSiyJjrmfx7NozOFkbs2Cix63az/eDrbkRPVpZsz0gDo1GMu/3ADRS8sXDHndVoDA30mfp1C7cyMrn+XVn2HwmFlszQ7q3urdFYQOcbWltY3pPfVRGE1ND+jvbsOlMLAWF2tKAP5+IZuf5eOYNcy73gao+MDXU44XB7XjnQVcsjOv3Q4OiKEpFqUBbaXAOhCRy6FISzw9qd9tmJW1sTFk+w5uY69k8ucav1K22a8qVa1m8vz2Y7q2s+PP5Poxws+eD7cH8cuJyuedm5RXwxCo/gmJT+XaqF30rkTc8pXsLIpMzORZRsXSVnPxCnv7Zn/wCDctmeGNWCx/xj/ZwICI5k//8cY6j4Sm8NaojLaxL3siio4M5H4x142h4CnsvJDLaw6FeloQb7+VIYnouvuEpBMel8cH2YPo72zC7jFKH9c3cAW2Z0KX+1npWFEWpLBVoKw1KfqGGj3ZcwMnauMTSYV2drPjyYQ9ORV3n1d8D0NTwNuU3aTSSV38PAOCLhz0w0NNh0aTODHSx5c3N58vchjs8KYNZq/3wu3yNhZM8GVzJsnojOzXFopE+a0+UvyhSSsl//jhHUFwaCyd50uY+zuoWN9zNHj0dwW9+VxjoYssjXcsuZzfRuzmPFJW8G+vZ7H4MsdoN7GCLRSN9fj5+mWfXncaykT5fPuyBTj18aFAURVG0VG0lpUH59WQ0YYkZfD+9S6mL4UZ7OBB3I5v/7bxIS2tj5g2r+O6BVfWjbyQnIq/x2QT3W1sMG+jp8O1UL2at9mPehgCM9HVvlbcrKNSw90ICa45fxjcsBX1dwecTPBjlXrWSdeO8mvHz8cskZ+SWuaDxR98oNp2J5ZUh7RlUyc1eqpOViQH92tvgH32dT8Z1qtAiwI8ecmN231a0tTW7DyOsfoZ6uoz2aMrPx6MRAn6Z1R3r+7D4VFEURak5KtBW6g0pJZcSMsjJL6RTM4u7ZvpSs/NZsOcSPVpbMbScWd8n+7YmKiWTJQfCaWdrxtjONTcLGpqQzme7QxjcwY6H7/jY3Ehfl2UzuvDojyd54dcz5OQXEncjm7Uno7mamoODhRHzhjkz0bs5NmZVD7qmdGvBSt8oNvrH8FS/NiW2ORqezMd/XmCYqx1zB7St8rWqy5cTPcjKK7xt2/Oy6Onq1Nsg+6aJ3s1ZeyKa5wa2o1cbtcufoihKfSeqa9e42ubt7S39/PxqexhKNZJScuVaNr7hyRwNT+FYeDLJGdpFjE1MDRnS0Y6hrnb0amONoZ4uH+0IZsWRSLY92xu3Zhbl9A55BRpm/HiC09E3WDe7B11alr7gLCIpg2d+OU07OzM+Hd+pwhU48gs1jPv2KLE3stn9Yt9Sg+X0nHymrThBQEwqAH3aNWF6j5YMdLGttoWID393lKT0XPa/0v+2hxSNRnI25gazVvthbWLAprk+aiORWpSYnoONqWG9LuWnKIrS0Akh/KWU3uW1U79NlTonJ7+Qb/aHsvlMHLE3sgGwNTOkTzsberaxxlBPh7+CE9h6NpZ1J6MxMdClb3sb9l5IYIKXY4WCbNCmbiyd2oWx3/ry1Bo/Ns/1wbHx3QvujoQm88wv/oC2bGBEUgbLZ3jjYNmo3Gss3h/GudhUvpvmVeaMtJmRPj893p3f/bU5yTVR8WJK9xa89FsAxyJSsLcw4mhY0QNMRAo3svIxN9Jj2QxvFWTXMluzis3gK4qiKHWfmtFW6pSzV27wyvqzhCdlMsjFlr7tbfBpa00bG9O7ZvhyCwo5Gp7CX0EJ7L2QQG5+IXtf7lfhVIObwhIzeOhbX5pZNmLjnF631U7+6VgU720Lpq2NKSse9SYsKYPn157BUF+X5TO6lLoVuZSSQ6HJPL7qFGM8HFjwiGel70V1y8kvpPvH+8jKKyC/UPtz72BhRK+2TfBpa02fdjb3ZUMaRVEURanvKjqjrQJtpU7ILSjk632hLD0Yjp25EZ9NcKdPu4qXsNNoJDkFhVXeVOXQpSQeW3WKAc62LJvehUIpeW9bED8fj2ZwB1sWTup8a6Y3NCGdJ1b7EZ+Ww+cT3BlTrMpFdl4hWwNi+enYZYLi0mhu1Yjtz/WpM5uN/HYqmiNhKfRobYVPmya0tDZWKQqKoiiKUkkq0FbqjaC4VF5ZH8DF+HQe7uLIW6M71sr2zKuPRvHO1iBm9nIiNDEd37AUnurXmteGudxVl/l6Zh5P/+zPichrzB3QhvFejvxyIprf/a6QllOAs50Z03u2ZGznZioVQ1EURVEaGBVoK3WelJJvD4bz1Z5LNDYx4JNxnWq1pJyUkre2nOfn49EY6Orw8bhOZW6ukVeg4Z2t51l38goAejqC4W72zOjpRFenxmqmWFEURVEaKLUYUqnTpJR8tOMCK45E8oB7Uz4c43bbLo61QQjBO6NdaWJqSN/2NuVue22gp8PHD3XCw9GSlMw8Hu7iWOn88HuSEg5RR6DzdNBRe08piqIoSl2jAm2l2kgpOXvlBm7NLNAvoySdlJL3twez0jeKmb2ceGd0xzoz+6uvq8OLg9tXuL0QgkndWtTgiEohJex8HaKPg/MIMLW9/2NQ6gYpISsFTFTdbUVRlLpGBdpKtflmfxgL9lzCxd6Mj8d1KnFGWErJu1uDWH3sMo/7tOKtUR3qTJBdr1zcAWF7oPdLELwFOk2ARmXPwNeKglyIPw9xpyH+HHhOgRY9antUDcvGWRAfCM+equ2RKMq9ubQbzv5y9+sPfAUm1pB1DfQMwcDk/o9N0SosAF0VOlaGultKtdh3IYGv9l6iT7smhCVmMH7pUaZ2b8G8YS63Km5oNJK3t2pzoGf3acUbI1WQXSV5WbDrP2DrCm0Hw6oHtDPaHceUf+61CO359m41O0ZNIfwwFK4GgCb/n9et26pAuzrlZYKNM5zfAKmxYFFzO5wqSo3LugZJIXe/fvPfEN9FcPRrsHEBBy9w6g0ek0D9HqlZUmrvcUIQ/DoVxi2H5l1re1T1hgq0lXsWnpTBi7+exdXBnOUzvCnQSBb8dYlVRyPZHZTA26M68kCnpvx383nWnYzmqX6tmT/cpf4F2QW5oKMHOrq1O44jCyA1Gh7bCY5dwcAMIg5WLNDeOBuSL8EcX7CsgZSXtKtg3lR7j+w6an8RNvPS/lK0cFS/EKvb+Y1w4CPtnyMOQueptTocRamSizugpQ94Ttb+VxqXUdoZ7djTcGknnP1Z+2+N+7AGc+EAACAASURBVMT7N9Z/m8IC+GMWtB0CbQZqX/t5PDy6FRxqf3+I+kCtoFLuSXpOPk/+5Ie+ng7fT/fGSF8XU0M93h7dka3P9sbe3Ijn1p2h/xcHWXcymmf6t6l/QbZGA34r4Yt22pnk2ta8B/R+GVr2Al19bTAbfqD881JjINYPctNg8zPa91WdUmNgSXftrBPAg9/AkPe0DwCWzbVBtpSQmVy91/03iz8H+iZg3EQbaCtKfZN4EdbPgIP/K79t864w4A2YtgFeDdMG54X55Z+nVI2mEDbPgaBN2t8b5k21AbaROax5CBIv1PYI6wUVaCtVptFIXvotgKiULJZM8aLZHVuSuzWzYPNcH94Z3ZHU7HyeH9SOecOc61eQnRAMK4fD9he1s9n9XqvtEUG7wTD4nX++bt0frkfC9aiyz2tkBQ+vgr6vQdRhOL26+sak0RQF7wXQ4cHS2219Dn4Yog246xONBsL2wm/T4NDntT2af8SfBztXaDNAG2jX9fu67wPY+552lkwp2bVI+GmsdrFzcmhtj6ZmSQk752lzrvvOq9y5Ojrw2J8N/1McKeH6ZTj/B4Tsur/X3f4inFsPg96GHv9v777jpKrOP45/zhaadAELRVABQQSk2XsDNYpd7MYSEzWJMUXTLL9UE2MXFRW7SLBhFDuChS6oFBEEkaUj0nd2p5zfH8+M22Z2Z3fvbP2+X6997c4tM2dm9t555tznPOentrxtN7jkVchuAk+eZv+vUi6ljkiV3fv+Et5dZKkhh+yza9JtsrMclx/Wg8sO7V6/AmyA2Y/DG7+Bpq1h5GgYMMp6ZSMFULCt5qs8fPk6rJpjgXJusTKC+xwDOFg9D9p1T71/kxaw/xnQdyS02BX6nRVc22Y9CsunwKl3Q/seqbfrdgjMfRpWzoRuBwX3+OnYsdGed2X/D6MReOhw2LDIvmwtngT9z7de+trkPaybDwecY3mqfUeCj4GrILVp7fz4wNRyLtFnQuEOu9oRC8PquXDO2OAH8BbugFmPwdAr6u+AuXC+5Sl/8xHMeAh6HAXDroJeIxreILQFL8HyqXDKnVU/n0Yj8N0S6NQn2LbVtk/ug2VTbCD5zu9sWY8jofdwK+3avB20aJ+Zx/Ye3rwJPn3KvgAdcWPJ9bvuYz3bU/8NLWtv7ov6Qj3aUiXvLFzH3e8u4cxBnbn8sO4Vbl/vgmyAPQZaQHXdbKuWkUh9eOJUmPDj4FMvylO403q4Fr9pwV5xHXrBb76G/Uem3n/Hd/Dhf2DbWnseB19jl/8iBeVfeg2HYM3n5bdt4xJ458+Wwzf4svK37Xsa5LaAz54rf7ug7Ih/QMVi1pP+yFHw6dP2eqYSzocVn9iHCFhw0/8cOOuxeGUPB9NHZ7zpFdq8wi7n7t4Pug6DPqemN35g3Ch45Rqr8FCTVkyzIPvAiy2InPlo8I/x9p/gnT9V/D9bF634xM4vu/WFX34Ov1oIx/7JgqpXroVoYW23MFgF2+CtP8AeA2Dw5VW/n9d/BWNH2LmqIt+vsOO7LvLerqAmfDsdtq6yL1in/Aeu/gAufBG2rob7h9gXykxqsSscch0c84fk6zv2hrPGWAdOaIt19NTkZ2I9okBbKm3m8k3c8MI8Dujchr+dcUD9DKJT2b4eptxhAWnnQTDyASsrleCc9QQun2K9uDXlwzthy0o45d9le7WcK9nGZBa/Du/dBtvXFS0LbYFHjrYAPJllU2D0ofDwEfaBmMqm5Vb15LT7Ku4tbtrKUkvmv5z5D7yv34f7DoTPxoGPwiHXQqQQJl4H/+ljzymRbrNyJrz2C+u5/nsX++D+8E4b3AnWo3PA2dB+bzj/OTj6d5ltezqatILh/7QeT7CKAPNfLH+faMSq1QC8el3RF5GasEd/+NE9MOIOuOo9K00J6QVI6Vi/yNKhDrwI9jokmPusCdEITLrJ/ucWvWbLsnPtmDry1/CLz+DHb1pAk7/ZvuTV9RShdBTusCD75DurN8C835mQ/33Ra5fKju/gnv7w8FF27qsrCrbb1dOHDofRh9gXK7A0v59Ns8+goVfAngdCThNovacNSpw1xs5nQQvn23n8qN/CiX+p+JzuPbxwsXVi/KObdUS9/SdYODH4ttVTCrQlbZt3FnLzS59z7sPTaNM8l4cuHkyz3FquwBG0Ra9ZFYf871NvM/hyK6v3zp9h49LMt2nbWitp1f88GwCZzIbF8PSZlhKQzKLXLLdu9/5Fy5q1sfzeqXfYpfyEHRvh5WvgqdMsFeGwX9hof7CTcOn82l4nwvVzbKBMOgacDwVbYPEb6W1fFTPHwDNnQ+sulq6SnQtDr7QPrsvesA+qGQ9Z+UGwLwsLXrZBhYf9As57Fn61KPlz6nWivXbV8eF/4M794KO7qz6Ya5dd7crErvvY7dlj4dXry//wzc6BC8bBNR/Z//jrN9Rc0Nayk13xaNLCAqzsHNi2Dh4YZu9XdXhvaV5NWsLxt9trsH1DIM3OqNAWeO5cmDEaDvop9D657DbZOdbLDbDwFbukv+Clmm1nJrTaHS54ofpl4rofCe16wJyx5W+3y6725W7jYnj2HAtwa9vOTdY7/b8bAGdfRFvtbuuyc1Pvd/BPrdNkwcvBtmfFNLhngFV1gfTS7Jyz1MqRo2HAefYFasZD6Q1ubSy89w3iZ/DgwV6qLhyJplwXi8X8K3Pz/OD/e9vvffPr/q+vL/TbQ+EabF0NevJ07+8d5H0sVv52W1Z7//du3j9yrPeRSrwWsZj3n//X+7f/VPFjJMx50vtbWnu/dn7qbbausW0+vKvsuvzN3t/ewfs3f1923c5N3v+7t/f3DfW+cKctm/WY97ft6v27txctS3jjt94/dIT3eXO8Xz3P+xmPpP88EqIR77940fuCHZXbLx2RQu9fu8Fei2fP8z60NfW2W9fY9on9KvM8Vkzzfsxx3u/4Lr3t87d4P/1h779fYbeXvu/94yOsnQ8c4v23M9J/7ISVs7z//tui2wtfs/tb/lHy7WMx7zd9U3R72mjv542r/PtXFds3ej/7ibKvV2ir98+eW/R+TXvQ+xXTK3dMeW/H1C2tvZ/5qPfRqB3DE64Irv2ZsGqu9/cN8f629t7PHpvePtGIHX//7l3+/3bCuoVF7+/n//X+6TOLfl65tvKvcxBiMe/f+4v33y0L7j4/vMve//WLk68vfh5b8Ir3t7b1/olTy57fatqH/7F2f/V25Y7DWMz+dx46Irjjd3Oe93fs6/09B3q/8/vq3Vc4VHSuWbsg9ftSzwGzfRrxqXq0G7ntBREuGDOdPn9+kx/d9xF/ePkLxs9eyeK124jGPN9s3MHFj83kF+Pm0bldCyZedxi/P7kPuzRtYINywHoXvvkQ+vyo4m/yrfeAU/8D0QLYmWa5uk3L4JkzrTpHt0PTH5S3e39LXejUN/U2rXaHjn2Sl3hb8o7ld/b5Udl1zdvB6fdbL89LV9myQZfCz6bDcX+C3JKVZNjrUOuFfPQ4q6U69d+VvwyblW2Xe5u0qNx+6Vg+FWY/Zr3S5z9rqSqptNq9qNcoO7dygySbtoK8WTDj4fK327bWeqvu3M+qK3wZ78Xf5xirmHDesxDabJP7TH8o/ccHGyfw9h+Lbvc4AlwWLEtR6nHVHLt0/uXrdvvga6wHKjH2IJO+fh9e+3nZyjhNW1kqzpG/tasLb95kVX4i8XSSL1+3mU8rat/u/WHYT6zHPCvLrlgsfNWO6bpqx0YIbYWLX6l4bENCVrbl625bA1P+Wf62ebPh4SNh2v12O5xvVzHyv7djeO7TtdMzPv9Fu4r29fvB3efACyErN3nqVDgfHjykqOxo39Nh5EOw/EP7HynP2vk2niBTOg+2XvaeJ1Tu/OMcHHSNlUbctKz67QiHYPzFEN5px2PzttW7v5ym0G4vGwP0xMnw7q3Vb2M91gCjJUnXtlCYSx+fyed5WzhvaFeWb9zBxHmreXbGtwC0aJJNJOZpkp3F7afvz4UH7UV2Vi3nY0cjNqCqdAAYhK/eipenSxKQJtPvLOhzul3aLdyZOnCMFMK0+yz3OyvX8t56npB+u/YcmN7EAPscY7l+4VDJqiTfL4c2XaHLsOT77Xs8HPyz+POP2od5h32Tb9v3dCsn+N7/wdxn4LxnqnZSjsUsHab1nsFONrHvcfCTqZaakEm77Q+9T7FLpIdelzyg37bOZu3cvNLyu4deYR+sxfU5FfY+Cib/3V5XsMAgp1n5H7yhrTYYctAlRcuatbH7X/YBHPvHsvvMew5ymkP3I0oun/MkLHnb3stMjbdY9gE0a5v8fcnKhmP/YD9b18CGL6Fpy6I2f/k/S9c6+V+pL6d37AUn31F0e/BlMPMR2//Q64J+NlXjvaVwbVlp4wV6Hg+/mFf5c1mXITagdPpoGHgRdNqv7Dbb1lkpylZ7WBAKMOhi+wE7/p4/r/z0hEyZ9ZjN7Jjul4t0tOxogwWTdUZ8dJedA/ccVLRswHlWpWSP/mW3D22xlLnm7WDztzZ4eL9TYcQ/bdKtIPU40n6qYsAoG+/SsmP12uA9vHGjfRE/75nk/09VldPUvgBP+YeNIdlt/+Duux5Rj3YjtTUU5pJ4kH3/BYP46xkH8NxVB/PZLSfy7q+O4j/nDuCyAS05f/CevHfjUVxySPfaD7LBiufffUDyaXqra2ueDXYrfkKuSGJg4v1DLbftv5dbWaZvPi7KAfzg7/De7dDzRLhuJhx0NSyaaHnQFfn+GxuoF4tWvO3eR1tP4MrpJZcf+Ru4/lPr6UvlpL9ZRY10BiU1a2ODMn+/yoKFqsjKstcg0ctUXd5D3hz7nekgO+HIG603OtXo/4/vsQoBl06EkQ+WDbITmraC4X+zD7hY1P4vFk8q/7HXLbDfux9Qcvnex9i60lVVIgXW29fnVKs2U1wsbMHs7AxVMfDeAu0eR1b8/9V6j3i5yrhzn7YevzljbYKM0j3U6xfB+EstsCxut/3ti+WcJ+rGwMHNK+H5UdZr+MWEonEOVe0wOP5WK+eYbP9IoU0Ak7/ZruokKwGXlQUX/tfKfdakWNSuXPQ4KvgZdnfvV/Yc993XNg7igHPsik9xiSB7zWfw+o1Wqea1X8KdfewcDvbF/ejfw9L3bDKuaQ8GVwN+xsM2yVdVNWlRFGRXp02xiOVVH/nb9DuZKuOgn9jYiVSD7hsBBdqN0Jb8MBc/NpP5q7bw4IWDGN5v9x/WZWU59u3UkjMHdeG32/7B7ZtvZrfWzcq5txq0YTF88V+75PrU6eldMvtiAow9pewHcTJH/gaunVX5Xr1YFIZdaZev82bZ5fwnToZ345PKHHItjHoBznvaenDBeu4+e77iYv+fPg2PD7dSWBXZ6zD7KR5YJMot5TQpf1/nKv/BV90PygGjrA50sgGc29dXbqbDvNnw6LEVV90IUufBFthOeyB5BZUTboMfvwXdDk7/Pr231I+Fr5S/XeI1261fyeWH/MxKPZa+urJ4kn0pGJCkdvaQK2Cf46xSQKLiQZC++9q+xBYPoNOVlWVB5RkPw8oZMObYoplFvYfXf20VgEqXvAQYcrnVV145szqtLykarvwMnF9PtiBt+RS7mnXFO9Wvh71LBzj7Mbs8X9pbv7cv2yMfKPtFrLRwyI6Zir6MbF4JT/4IVs6qepvBSoGGd2Ru6u5P7odx8R58760kanYTOOH/Uu/zzcdWQerhI+ycvP/Iokm3cppahaFrp9ug6rduhjd+Xf125s2GSb8tSuOqqmjEPt/euzX5eu+LqvoUbLP0tJUzS56vsnPh7LFwdIZmPW7RHob82NKUgjy/JK4QBT0gNAMUaDc03tslxUSPVylbdoa5+LEZLFq9ldEXDubE/XdPuh2xqI08TuSYZlI6vbVgH6YHnGM9hJEQvHR16g+IWAze/wu8eAWs+MjSFMqT6BGoygdgVrb1up33NNwwH369BC4Yb7nOYB+KvYeX3Cdxu6Jaxkvfga4HpZee0bSl5f0WD2gmXgfPnZ/+c6lJ/c6yVJp5zxcti8WsF/L+IfDilemXfvssnhbR88SMNDWlY/9oAXUi0CvYZrNfbt9gH2DJLk2XJzvH6uYuebv8Xqp1X9il7cQXt4Tm7ZKnMH0+3tII9j667DrnLE8/O9d604Oe0np1vIJBssdO14Dz4dL/Qa/hVt8XLEBc8REcd0vy8pZ9R1qFma4pUqYqa+cm61V/+sz0A4aC7XYOatvNxj0cen2wk85sWm7vWWhr0bJeJ1nt43QmpJr/ouX6f/1e6m1iMbuSuHxq9VMndm6EtntZqbpMiEXs6kwid3n5VDjm5vIrIh3yMzj1Ljjxr1ZpaOSDZb8ItOtuVwDOecJyo6tr+mibCG3gBdW7n+wcq+Yz56myVVQiBTYe6IWL7DN27Rfw5u9sPoG/d4HRh1nu+qZl8Y6WDIaDh1xnqWOJKk9B2LTMrtzMfrxuXLUqTzojJuvDj6qOxM191kYxj7uwzKrvdxT4U+6d6nv+4Q3//qJ15d/Pmi/sfsYcZ79XfZqZ9n76tPf3H1T50d+r5nq/YUnq9XlzbGT5Kz/zfvyl3v+ju/eF+am3n3CFVT2oSfcN9f7J01Kv37bOXvsp/6rc/Ya22XONFHr/967ev/ST6rUzk8Zd6P0d+1hb1y30/tET7Tk/frKNVP9+hfdfTCj/PsIhe54TrqyZNqdSsMP7sad4f2s7qyJQVfNfstfgm49Tb7PpG++XTUm+7rMXvB9/WcllO76ruLLJFxOKKiAEbdu6YKubrJprbX34KKvEkWnrFnl/d3/vb+9olVqiEe/fucX7T5+peN8l73j/3deZadfK2d7f0sYqChVsr/z+4QLv7+zj/WPDU28zbbS91rOfqHo7a8q29VYxadJNdnvT8qLKQkHaucn75y/wfuHEyu+7Oc8qzSSrAlUV386092fGI0XLtq0vOpdO/nvRsbdllVUnevc2q7B1/0Her/8ymHZUpLzP33RFwt4vebfo9teTM/P+pglVHWmENq+ESb/DuyzyN63mzS/W8MDkpfxq/DxOf+BjDv/nZL5at50xlwzhmP06lX9fefFLhCf/y3oK5zyRmTa33cumtv7o7vK3m/us9VIk7DnQBux5b/l0icvJiUtinQfBVZPhtPvtcu1PPyk5QLC4SIHNuFjdQSWV1Xu4XbYs3htV3NJ4L9O+lciDXrcQ/tkdvnrTKqiEtmQm7y4oAy+ylJtVn8JDR8DGr+D0B+Gy/9kAt4/vsR678moiL55kz3NALfXcRyP2PzjmWKtQcMbDlRvsWto+xxZN9Z5Ku71SD6LascEu0xbP/2zRvuKe3X5n2XFSnban0rJTsAMtP3/BXqOKJjuJRqy+9uzHq/5YS96xXsDCHfZ/OeA8O++smmNX+1bNKbuP90W9d/seb2M/MqHLYBsQO3003DfYBrZWRk4TOPTn8O0nNjNlaRu+shS4nifZ46ydD4+PKJrIqa5p2dHGIUx/0D4L2nXPzIDPJq3sasKbN5c/y2wysx61wZbDrgqmLV2HQuch9j8Qi9l7NOZY+/875wk4+qaiY6/1nvb6HPdnuOQVS4np2DuYdlQkt5kdF1Wde2LVHBhztFXuWjvflu19dO0M6K0kBdoNyeu/IhKNcKa7mz4rbuSaZz/lX28t5pOl39GyaTZnDurM81cdzFG90ggo82bbJdo9Blopti8mpJcnXBlL3rGqAPueYCPDU+Vcb10N//ulVXgo7bulliLy9EhY+i7cO8juFywYd84udyYuHSZLU1k2BQq3FeXl1ZTep9gMdjtSBJHLPoBdOpWcZKYiHXpZxYplky1/LXcXC9zqqt7D4eKXoNtB9qXuutlw4IVFHwwHXWOlCcsLlBZNTJ0WUROysm3swIZFNjtm/3Oqd3/N2lgudcvdkq/futomeNm+Pvn6vY+234lc4levKyorWJFEVYBvPi45iVEy6cwquepTS10KOvf7pL9ZilaXFANME7JzLOCY9kDVLy+vW2AdAldNLvqykp0DZz9h79ELF5d9Lz6+x2ZdzZtdtcesjONusQGuoS1WkaSyBl1iEzVN/XfZddPuswGXp91rx2STFhbwvJ2kqk1FYlG4b0jmOm0SEtO5v1dOXnZ1ZefYgPAtK20G2coo2GrVm9p1D649B/8UNn1tHSzjL7EBzj+eVPODXSsy5Q546LDU565kQlvhjd/CmOOsQ+3cp+pf9ZJ0ur3rw09jTx3ZtL3A/2Xsi/6qm2/xP7rvQ//inJX+sxUb/baqTizzzcfez3ve/k5cmpr1eHAN9t77t/5oE6lsXun9Xzt7/8zZyS8vT7rZLsdvWp78fpa8Y/dzS2vv7zrAUhBKK9xp6QhT7yy77pVr7fHDoWo9ncCFQ3bJurKeO9/7//SzyQdeuCT4dtW0Z86255Lq/QmHkr/nNem7ZXYZsyYkJmdZ83ny9bGYvV7//bFNcnRLa++nP5T+/UcKvb97gPd39rVL0KVFo96//zebsOm7ZfaTvzn5fX1wh6U2bN+Y/uMHLZFOt2xq+vtEo0Xnm1gsdWrb6nne/99uNvlQ4hL2knctbW38pTUzGVCiHavmVn3/qXdaGk5oW8nlkUKbcKS49/8Wfz1TpC6lsm6R7Tf3uaq3Mx2JScGqO+lKOl682j57yktjTCaaeoK4KokU2udzaJv3qz+zCdXqog1L7Nh4+8/pbR8Je3/vYDuHvP5rm/irDkGpI43H5M+WceLdU3liSTMOOO5CXvrpoZwZfZP+/z2cltmxqt3pXocWXYrvMsS+gVd32unS1i2weqptutjlrSXvWBWK4nZstNJe/c9N3QOw7/FWZH/gRdbr1KlP2W1ym9ulq2kPlLzUF43YVOC9TrIR5rVh56bkPe05TatW03TvY2DLt1a7eciPq9++2nbQNbBjPcxPMblGTtPk73lNat8j+B71aMQGI5e2br4NIu2Q4pKvc9aWZR/YFaOsnPQGxiVk59ol550b4b+XlRwcWbgTJlxudXH3O9Ve+9GHwuS/Jb+vZZNtQGiywYo1Zf8z7NyVbk+q9zZxzkNHWjqec6nL8O0xwK5i5M223vtNy2xwYcc+cPoDmatLnqwd1ankcej1du5M1C/fuMTOS9m5RdO/Jxz+S+vhf+M3lRs4u2ae/c5UxZEE5+zcV91JV9Jxwu12BXHyXyre1ntLxYHgBx5m51qVnaYt7Xgrb/Bnbeqwrx2Psx6ziZNS2bbWXq/sHIsNrnzPrniWLk1aTyjQrse25If5zQtzaP/iWfwpayyvXns41x/Xk5zsLGjdBbathm+mVv6ONy230dqRQrvtnF2u6XdmsE+geAH7g35iEw6ULkeVyLU7/Ffl31fPE6ycVXkf6Ef82oKHT58qWhaLwDG/r72A9OvJ8K99ypYgm/MkvHtb1S537320/e7QyyZDqe/2ORZ2O6DsrIJgpbzmPlPjTaoRT5xslXVKW/uFfUEtr2Rj7+EW0MwcY/m1u3So3GPvORB+dK9V9UikCWxdDWNH2Gx6J/7FKpW03tMqJ8x8pGyZxoLt9n+999GVe+yg5Ta3VJxFEytOd/HecpJnPmyTu6RTZaP/OfDzTy3AGXeRLTv/WWiyS/XbXlMSM6Pu3GRfFsZdaLmwyc4/uc1hxB02sVBljr3V8yC3hZ2XGopWu9kkL6ekUSN62WR4YCgseTfz7arLjrjRUjWnFJtgas1nlqq2ei58fC/ce6Cl44F9aaooRayO08yQ9dTyjTu4cMx0ztnxHANyltH31D+Tu2exb3t7H21F4he9VrnBdGD/4JP/BjetKPlhXrjDPkzLqwscDVvpvfKmvgb7wNu+tijQzs4t6unYts5OYAAu2z4kOwZwct7rEKsz/cm9FljnNLFe7qFXVv++q6rzIJs2+6tJ1r6ExJeBqvSIdegJI/5V9RnH6hrn4OrJZQe9rJ1vpbwayvMsrdshNn12aEvJq0lr51dck7rfWVY+bOm7MDBJ7ex0DDjPeiGnP2hl9RZPsjERo8aVLFd57B+tlu3rv4bLJxX11n07zXJF9z66ao8fpMGX2fTS0YLyt5tyh+VXD/mxfZlI9/hr08WC0oGjbHbC9j2q3eQaFymEBw+283doC1z0Uurn33s4nPMk7HdK+ve/Zp6NNwl6opralujMiEWt4ybVldHpo23MTemJcxqbxKy6m78tWjb2FAu+E3qNqNz8A3WcerTroXVbQ1z82Ax6hJfwy9xX4IBzyD2g1KCH3GZWU/jL19OvU52QN8t6zEqnirz1e3jmrOSDIhdPskEL/9jL0jMqsmODXfou3YP96dM2w2Ji8NSxf7C6pkE54kbYusqqFnhvNZzTGdSVKc3aWPC/+M2iZTs32YCjyn5BSnDOZp/cdZ9g2lgXJILszSuLln32fDwt4uzaaVOm9R5hH9xLi9U43rkp/gW1X+r9ErKy7WpAz5Oq3oYT/g9GjraZ/E64zdILSteEb97OLqGvnA6fjyu5ruvB9oWhtnXqYykerfe0qgdv/r7seWzhq/DB32DABVbNpLJfcp2zFIx9jwuu3TUpp4nNUxDaYp0PFT2P/UfacZlurfuuB9k+DVE43yp9TPln2XUbl1p1kiVv2+taWymKdcnIB2yCuIRzxtoX+FHjbEKnUc9b7fkGQoF2PbMlP8ylj89k646dPNb6UVzLjpa7lEyfUy2gXTkj/Qfw3gLtZKPXB14EhdutAklxs8fC8+fbFM7tuheVBixPp/1sOvK9jy65fN/jLXh6/VdWDcT7YPMc9znWAof9z7CJNF65xk6AtanXcNi4uKjqytfvAz4zZdbqs9lj4Z7+lkISjdgkLD1Pqt3830zqMhSat7dKAgkt2sNNKy2toSL7HAsXv1zxrKDlyc6x1JCsLEsZSHVlacAFFlAXT+/peQJc8VbVpxnPlGWTrZf+/mGw6H9Fy3uNgOH/tJSYTE7eUZcd+Rs46e/2xSkda+dbx8jyNFIUpxEHAwAAIABJREFUT7jNqmM0RLnNrXPqk/sssC6ecjPhMkut6nc2HBzAZDcNQfN2JXP1e55gHQu9R1hln5oa21BDGunZpH4KhaNc+eQsvt6wnbGndaRZaL1NT9y8XfIdep5ouc2lZ48rz6ZlNkihy9Cy67oMsZ60OWOLln02zmrJ9jwRDr7WcqnyZle9lFbrPWzww7IP4KnTYO3nVbufVJyzwKFpPK0mK8cGQtam0rNELn3PAqxMzZ5WX/U80dJsZo6xYGnH+qqnRdQHWdn2nEvPEtmsdfADk6srKwsufc3GO4D18CWblr4uGHaV9Zq1aA8vXAh3H2CDr3KaWCDU0FIbKqN5W5spMd388l33sZrQM8eUv11oS/AzjtY1iYGR4y+2FJzE/Ain3Q83LISzH6t7x63UCAXa9UQkGuO65z5l9orvueu8gQwechD8boVd6kulaSs4/pbK1etM9EYnC7Sds1zHNZ/ZCPsFL9vUvD2OhHOftg+qLkMhtLniurnPnQdv/yn5uoN+YvW7e55oo+kzYfEkq93d/XD7wK1N7fe2k3Ei3zG3mVV5acwf+Mm06WzTan/6lF2yPuCc6qVF1AeHXGvHVqKHZ9oD8Mn9tdumVBLpPd9Ot0vo/9ir6pNTZFrXoTb4+oTbbTKkytZCFpPb3K4OLnk79cRbYGN+/t3LJlRpqFrtZhPBrF9o9dUT8yPsObBozJE0ShoMWQ947/ndi1/w7qL1/N/IfpzaP95D7ZwNFixPNAzLp1gwl87sZPufAbvum3q2qP7nWoC88BWbrbHLMMunSsy6mAjQ82ZZKZ9kYjG71NguxYCh7Fy48l0gg5ePEifBujKZS/FUgFPvqr121HUH/wzmT4ANi+GsR2u7NZm3R6nJiuY+awPvDr2udtpTkXA+vHCRHV/N22VuRsQgZOfCYb+wgY+59ahCSF3T7yyr0rJ4kg2gTWb1PBuk3dBTcoZdFS8tmOIqszRKDfy/vmH4x6QvefHTPG44vhcXH7yXLXztlyXL46RSsA2ePTf9Mkw5TS1FJFVvarM2cP1s6wm69DW4cHzJy4wdetu3+vLSHr5fbhUAypvdKTvX8kMzZeBFcN6zcFAdyRmMFFrOcWI2P0muy2CrXFCZcQf13ZrPrcc1UmC5/LunMRCytuQ2h+Nvs797HFU/AqumrepHO+uqLkOhTVeY/2Ly9bGopQA2llQ4BdlSinq067ipX23g4anLuOSQvfj5cfEeYu+tJmzvkyu+gxbtLT1i0WsWAJencKdNZz7wgvI/zBO1ZUtPZAD2gXXEjeU/zroFqfevKVlZNli0rsjKhkm/g/xNlh5x7pO13aK665Q7rfessVjxCbx3u/UOxyLpVRypTQNGwcavKlf6TeqvrCzreEk1QczGr6xjZY8MT1QjUkfpa3wdN2FOHm1b5PLHU/riEnma29fDzu/S/8Dt8yM72W1YXP52a+bB9Adgy8ryt6tIaKsV5S8+A2Nx6xcCzmZPE5OVXVQ3tN1etduWuq7rMBt70FgkBstO/bf9Ll0Ss67JyrIKE12H1XZLpKb0OzN1Gt7qGpoRUqSOUqBdh20viPD2wrWc2n8PmuQUe6sS05Sn2yO8X7zndtHE8rdLDITsnKS0X2V8Ow2ePcvK5yXTtpv1ejVpUb3HaWgS79M+9bQOr2RGu+72pXTdfGi5e93Oe5bGa/2Xyae53/NAOPZPDWtGSJFKUOpIHTbpizWEwjHOOLDUNMDrF9rvTuXkOBfXeg8btLjik/K3y5tlH+otO1a6rSUkAvW8WZa2UtrAC+xHShp4gfUCduhZ2y2Ruqb3cPhuCVw7Q9VopG6aP8HGEvQ+GVp2KlreaT/7EWmk1KNdh708dxV77dqCQd1K5b7lNofuR1Ruoo7znoELUwxWAcv7XjnLAvLq2mVX63XLm112XSxqg7qkLOcUZEtyvUbYoOOK0r9Easv+Z1pN7YWvFi2LRW1egNCW2muXSC1ToF1HrdmSz7Rl3zFyYOei3OyEoVfCZf9LvmMqrXaz3MlUdUzzvwcfTV4/uyq6DLUe7dIT16yeB3/do+S00iJSvi5D4TdfQ7eDarslIsnt1tdSnIpXH9m4BJ45s3ENXhYpRYF2HfXK3NV4D2cc2LnkiqrOuAgw4xEYfYiVCyutRXv49RIYcnnV77+4LkNh+zrYkldy+foFFtC3T1FDW0TKysoqmhBGpK7qd5aN0Umc91fPtd+qOCKNWEYDbefccOfcYufcUufcTUnWd3POTXbOzXXOfe6cOzm+fNf48u3OuTo6DVrmeO95eW4eg7q1pXuHUhMpbPwK7tinaj3CvU6yutpPj7SBK6U5F9yHed/T4ZqPyk7/vm6BTQ7RtnswjyMiInVDvzMhtwWs/cJur5ln53ulxEkjlrFA2zmXDTwAjAD6AqOcc6XLZPwRGO+9PxA4H3gwvjwE/An4dabaV5ctWL2Vr9Zt54xBXcquXDcfdm6EXaowYLHdXjbJTFYOPHV6yWnSX7wSpv6r6o0urWUnK0NWeuDWugXQqY8miBARaWh23Qd+uwx6j7Dbq+cl/xwQaUQyGe0MA5Z675d57wuBccDppbbxQOv4322A1QDe+x3e+4+wgLvReXnuKnKzHacesEfZlesW2rTrqaZIr8iu+8AlEyEWtmB7x3c2K+Gi1yB/c/UaXtrS9+Dje4pue2+BdnkzQoqISP2V29x+Rwob14yQIilksrxfZ6D4zCd5QOmRPLcCbzvnrgd2AY6vzAM4564Grgbo1q1blRtal0SiMV6dt5pjenei3S5Nym6wboFdhstpWvUH6bQfXPwyfPm65WavnguRkE29HqRlky0v/KBrrL2xKBx+Q92eQlpERKouHILHToA+p8GP37JqOSKNWCZ7tF2SZaVH8o0CnvDedwFOBp52zqXdJu/9I977Id77IR07VrP2cx3x8dffsXF7QdlBkAnrA+oR3mMAHPN7y8v+/AVbFlTFkYQuQyFaAGvjE+xk58BhP089g5iIiNRvuc0sT3vBy7BHf7uKKtKIZTLQzgO6FrvdhXhqSDFXAOMBvPfTgGZAhwy2qc57+dM8WjfL4dg+ncqujMVskGHvk4N7wGgYZjxkf7dOEdxXVfGJawC+/6ZsFRIREWlY+p1pnUKT/17bLRGpdZkMtGcBPZ1zPZxzTbDBjqXnAP8WOA7AOdcHC7Q3ZLBNddqOgghvLVjHKf33pGlOksEjWVlw4l/ggLODe9DsXPjJh3DFO9a7HaQ2naHVnrAqPnHN5L/BoycE+xgiIlK39B1pv6f8o3bbIVIHZCxH23sfcc5dB7wFZAOPe+8XOOduB2Z77ycCNwJjnHM3YGkll3lvhaKdc99gAyWbOOdGAid67xdmqr11wZvz15IfjnLmoBQ9yzs32SW53GbBPvAe/YO9v+K6DCnqxV63UAMhRUQaula7wVE3Qcdetd0SkVqXycGQeO/fAN4otezPxf5eCByWYt/umWxbXfTy3FV0bd+cIXu1S77B+3+xvLffLgu+9zlTzhxjXwyiYdjwJeyr/GwRkQbvmJtruwUidYKKGdcRa7eE+PjrjZyRbMr1hPULraxffQmyoaj3/bulVlJwN1UcERERkcYhoz3akr673/0K72FkqmojiRrU/c+t2YZVl/fw0tUWaAN0Kj1nkYiIiEjDpEC7Dnh2xgrGzVrJz47eh707tky+0ZaVULC1/gWqztm08eGdcNZj0EE5eyIiItI4KHWkls3+ZhO3TlzACb3acGO/nak3XBcfB1ofUy+6DIWtq2H/MyAnySQ8IiIiIg2QAu1atG5riJ8++yl7tm3OfV0+IPvRY+Dryck37tgbTvwr7FbPerTBKo8UbreZKEVEREQaCQXataQgEuWaZ+awoyDCIxcPoVl0u62Y9DuIFJbdoX0POPQ6aNqqZhsahM6D7ffCV2u3HSIiIiI1SIF2LfDec8urC5j77WbuPGcAvXdvBSP+AaPGwcbFMGN02Z2WT4Vt62q+sUHo0NOe26l31XZLRERERGqMAu1a8OyMbxk3ayXXHrMPIw7Yo2hF7xHQawQs+p9V60iIFMBTI2HmIzXf2KD0HgHNWtd2K0RERERqjKqO1LA5K77nttcWcHTvjvzqhN628PP/wqwxcP7zMPJBaNq6ZK3sDYvBRzWrooiIiEg9oh7tGnbXO1+x6y5Nuef8A8nOigfT33xosyY2bwct2kN2DuRvhvVf2vp1C+y3Am0RERGRekOBdg1auWknH3+9kfOHdaVN89xiK2ZA14Mgq9jb8dy5MP4SGxi5fgFkN4X2+9R8o0VERESkShRo16AJc/IAOHtwl6KF+d9bb3bXYSU3PuLGooGR6xZAp/2sp1tERERE6gVFbjUkFvNMmJPH4ft2oEu7FkUrVs6y310PLrlDr5Og98nwwT9h1PPQZJeaa6yIiIiIVJt6tGvIx19vZNXmfM4d0rXkiia7WKWRzoPK7jT87zYIcs5Ym/RFREREROoN9WjXkPGz82jTPJcT+u5WckX3w+wnmXbd4fBfwZK3bXBk87YZb6eIiIiIBEOBdg3YvLOQtxas5YJh3WiWm120IhqBgq1WaSSVI34Fe/S3kn8iIiIiUm8odaQGvDpvNYWRGOcM6VJyxdrP4Y4e8NVbqXfOzrXJXrL0VomIiIjUJ4reasD42SvZf8/W7L9nm5IrVs6w37v1q/lGiYiIiEhGKdDOsPmrtrBg9VbOG9q17MqVM6BNV2jTueYbJiIiIiIZpRztTHn917BjPf9t8hua5GRx+oBSwbT38O0M2OvQ2mmfiIiIiGSUAu1MiUVg4aus4wCG7388bVrklly/ZSVsW20zQoqIiIhIg6PUkUwZ8U92tOjMdbFnOHdwktSQpq3g1Luh5wk13zYRERERyTgF2kGLxeD9v8LmlTzV7EL6ZX3DoaGpZbdr3g6GXA7te9R8G0VEREQk4xRoB235FJh6B98tncG/1/RnQ4t9yfrkHsvJLu7L12Hzytppo4iIiIhknALtoM0ZC83b89zWAcTIInrGI3Dxy+Bc0TYF2+CFi2Du07XXThERERHJKA2GDNK2ddZTfdA1zFy5g/33bM3uPQfbOu9tgGR2LuTNBh+DrsNqt70iIiIikjHq0Q7SvGctmB58GfmFUVo3i1caKdwBY46Fj++x2ytnAg66DK21poqIiIhIZinQDlIkBD1Pgg49CUWiNMvNtuVNdoFWu1ugvXMTrJwOnfpCszbl35+IiIiI1FsKtIN0zO/hghcACIVjNMst9vIe92fLzf7wTksd6ab62SIiIiINWVo52s65F4HHgUne+1hmm1RPbVoG7Xr8MOgxFI7SLCe7aH2nPjBgFMwcA5dPgpadaqmhIiIiIlIT0u3RHg1cACxxzv3DObdfBttU/2xbB/cPhU/u+2FRKBylaW52ye2OuRnwsOAlaNu1ZtsoIiIiIjUqrR5t7/27wLvOuTbAKOAd59xKYAzwjPc+nME21n3znrFBkL1P/mFRmdQRgLbd4OJXoMuQGm6giIiIiNS0tHO0nXO7ApcBVwJzgXuAQcA7GWlZfRGLwZwnofsR0GHfHxaHwsUGQxbX/TDIaVqDDRQRERGR2pBujvZLwH7A08CPvPdr4qtecM7NzlTj6oVlk2HzChvsGBeJxojEPM2TBdoiIiIi0iikO2HN/d7795Ot8N437jyIz8ZBi12hz49+WBSK2HjRMqkjIiIiItJopBsJ9nHOtU3ccM61c879LENtql9+dA9cOKFEOkgoHAVInjoiIiIiIo1CuoH2Vd77zYkb3vvvgasy06R6pkkL6DyoxKL8wnignaNAW0RERKSxSjfQznIuXiAacM5lA00y06T6ryBigXZTpY6IiIiINFrp5mi/BYx3zj0EeOAa4M2MtaqeC4UTOdrq0RYRERFprNINtH8H/AT4KeCAt4FHM9Wo+i6Ro62qIyIiIiKNV7oT1sSw2SFHZ7Y5DYN6tEVEREQk3TraPYG/A32BZonl3vu9M9Sueq2o6ohytEVEREQaq3QjwbFYb3YEOAZ4Cpu8RpLIV3k/ERERkUYv3UC7uff+PcB571d4728Fjs1cs+q3H3q0Vd5PREREpNFKdzBkyDmXBSxxzl0HrAI6Za5Z9ZtmhhQRERGRdCPBXwItgJ8Dg4GLgEsz1aj6riDRo91EPdoiIiIijVWFPdrxyWnO9d7/BtgOXJ7xVtVzSh0RERERkQp7tL33UWBw8ZkhpXyhcIwsB7nZeslEREREGqt0c7TnAq865/4L7Egs9N6/lJFW1XP54SjNcrPRdxMRERGRxivdQLs98B0lK414QIF2EqF4oC0iIiIijVe6M0MqL7sSQuEYzXJUcURERESkMUt3ZsixWA92Cd77HwfeogYgFImq4oiIiIhII5dut+v/gNfjP+8BrbEKJOVyzg13zi12zi11zt2UZH0359xk59xc59znzrmTi627Ob7fYufcSWm2s04oCEdVcURERESkkUs3deTF4redc88D75a3T7ws4APACUAeMMs5N9F7v7DYZn8ExnvvRzvn+gJvAN3jf58P7A/sCbzrnOsVr4BS54XCMU1WIyIiItLIVTUa7Al0q2CbYcBS7/0y730hMA44vdQ2HusdB2gDrI7/fTowzntf4L1fDiyN31+9kK/BkCIiIiKNXro52tsomaO9FvhdBbt1BlYWu50HHFRqm1uBt51z1wO7AMcX23d6qX07p9PWuiAUjtKmeW5tN0NEREREalG6qSOtqnDfyYpIlx5QOQp4wnt/p3PuEOBp51y/NPfFOXc1cDVAt24VdbDXHCvvp9QRERERkcYsrWjQOXeGc65NsdttnXMjK9gtD+ha7HYXilJDEq4AxgN476cBzYAOae6L9/4R7/0Q7/2Qjh07pvNUaoTlaCt1RERERKQxS7fb9Rbv/ZbEDe/9ZuCWCvaZBfR0zvVwzjXBBjdOLLXNt8BxAM65PligvSG+3fnOuabOuR5YTvjMNNta6woiytEWERERaezSnRkyWUBe7r7e+4hz7jrgLSAbeNx7v8A5dzsw23s/EbgRGOOcuwFLDbnMe++BBc658cBCIAJcW18qjkBiwhoF2iIiIiKNWbqB9mzn3H+wcn0euB6YU9FO3vs3sJJ9xZf9udjfC4HDUuz7V+CvabavTslXjraIiIhIo5duNHg9UAi8gOVU5wPXZqpR9Vk4GiMa80odEREREWnk0q06sgMoM7OjlBUKW4aLerRFREREGrd0q46845xrW+x2O+fcW5lrVv0VCscAaK4ebREREZFGLd1u1w7xSiMAeO+/Bzplpkn1W6JHu6kCbREREZFGLd1AO+ac+2FGGOdcd5JMICNW2g9QjraIiIhII5du1ZE/AB8556bEbx9JfEZGKSm/0FJHmuUoR1tERESkMUt3MOSbzrkhWHA9D3gVqzwipYTUoy0iIiIipBloO+euBH6BTYU+DzgYmAYcm7mm1U9FVUcUaIuIiIg0ZunmN/wCGAqs8N4fAxyITZUupajqiIiIiIhA+oF2yHsfAnDONfXefwn0zlyz6i/V0RYRERERSH8wZF68jvYrwDvOue+B1ZlrVv2l1BERERERgfQHQ54R//NW59xkoA3wZsZaVY8V1dFWj7aIiIhIY5Zuj/YPvPdTKt6q8UrkaKtHW0RERKRxU7drwH5IHclRoC0iIiLSmCnQDlgoEiU7y5Gb7Wq7KSIiIiJSixRoBywUjtEsJwvnFGiLiIiINGYKtAMWCkeVny0iIiIiCrSDlq9AW0RERERQoB24gnBMpf1ERERERIF20ELhqCqOiIiIiIgC7aCFIlGaN1GgLSIiItLYKdAOWCgco5lSR0REREQaPUWEAVPqiIiIiIiAAu3AqeqIiIiIiIAC7cCp6oiIiIiIgALtwGnCGhEREREBBdqBC4WjNFegLSIiItLoKdAOWCiiqiMiIiIiokA7UOFojGjMq+qIiIiIiCjQDlJ+OAqgHG0RERERUaAdpNAPgbZeVhEREZHGThFhgArCMQCaqkdbREREpNFToB2gRI+2qo6IiIiIiALtAIXiPdrK0RYRERERBdoBCkWUoy0iIiIiRhFhgPILVXVERERERIwC7QD9UHVEdbRFREREGj0F2gEKRRI52npZRURERBo7RYQBCmnCGhERERGJU6AdoAIF2iIiIiISp0A7QEXl/fSyioiIiDR2iggDpNQREREREUlQoB2g/HCU7CxHbrZeVhEREZHGThFhgELhGM1y9JKKiIiIiALtQIUiUZo3UdqIiIiIiCjQDlQoHKWpJqsRERERERRoB6ogHFPFEREREREBFGgHKhSOquKIiIiIiAAKtAOVr0BbREREROIUaAfIerT1koqIiIiIAu1AhcIxmqtHW0RERERQoB2oUCRKUwXaIiIiIoIC7UAVhGM0U3k/ERERESHDgbZzbrhzbrFzbqlz7qYk6+9yzs2L/3zlnNtcbN0/nXPz4z/nZbKdQVGOtoiIiIgk5GTqjp1z2cADwAlAHjDLOTfRe78wsY33/oZi218PHBj/+xRgEDAQaApMcc5N8t5vzVR7g6CqIyIiIiKSkMnu12HAUu/9Mu99ITAOOL2c7UcBz8f/7gtM8d5HvPc7gM+A4Rlsa7V579WjLSIiIiI/yGRU2BlYWex2XnxZGc65vYAewPvxRZ8BI5xzLZxzHYBjgK5J9rvaOTfbOTd7w4YNgTa+ssJRT8yjqiMiIiIiAmQ20HZJlvkU254PTPDeRwG8928DbwCfYL3c04BImTvz/hHv/RDv/ZCOHTsG0+oqCkWiAEodEREREREgs4F2HiV7obsAq1Nsez5FaSMAeO//6r0f6L0/AQval2SklQEJhS3QVnk/EREREYHMBtqzgJ7OuR7OuSZYMD2x9EbOud5AO6zXOrEs2zm3a/zv/kB/4O0MtrXaCsIxAJrlKEdbRERERDJYdcR7H3HOXQe8BWQDj3vvFzjnbgdme+8TQfcoYJz3vnhaSS7woXMOYCtwkfe+TOpIXZIfVuqIiIiIiBTJWKAN4L1/A8u1Lr7sz6Vu35pkvxBWeaTeCCnQFhEREZFilOcQkFA8dURVR0REREQEFGgHpqhHWy+piIiIiCjQDoxSR0RERESkOAXaAQlF4lVH1KMtIiIiIijQDkyoMF5HO0c92iIiIiKiQDswmhlSRERERIpToB2QRI528yYKtEVEREREgXZgQpoZUkRERESKUVQYkFA4Sk6WIydbL6mIiIiIKNAOTCgcU362iIiIiPxAgXZA8sNRlfYTERERkR8oMgxIQTiq0n4iIiIi8gMF2gEJRaKqOCIiIiIiP1CgHRDL0dbLKSIiIiJGkWFAQuEozZQ6IiIiIiJxCrQDEgpHVXVERERERH6gQDsg+UodEREREZFiFBkGpCAcpal6tEVEREQkToF2QELhKM0VaIuIiIhInALtgIQiSh0RERERkSKKDAOiqiMiIiIiUpwC7QB471V1RERERERKUKAdgMJojJhHqSMiIiIi8gNFhgEIhWMA6tEWERERkR8o0A5AQTgKKNAWERERkSIKtAOgHm0RERERKU2BdgBCkUSPtl5OERERETGKDAMQSqSOqLyfiIiIiMQp0A5AfqFytEVERESkJAXaAQhFEjnaejlFRERExCgyDEBIVUdEREREpBQF2gFQoC0iIiIipSnQDkBBWKkjIiIiIlKSIsMAFJX3U4+2iIiIiBgF2gFQ1RERERERKU2BdgB+mBkyRy+niIiIiBhFhgEIRaLkZjtysvVyioiIiIhRZBiAUDiqWSFFREREpAQF2gEIhWM0VX62iIiIiBSjQDsABeGoSvuJiIiISAmKDgOQH46q4oiIiIiIlKBAOwAh9WiLiIiISCmKDgMQCsc0GFJERERESlCgHYBQJErzJgq0RURERKSIAu0AhMIxmqpHW0RERESKUaAdAFUdEREREZHSFB0GQFVHRERERKQ0BdoBUNURERERESlN0WEAVHVEREREREpToF1N3ntVHRERERGRMhRoV1NhNIb3KEdbREREREpQoF1NoXAMgKY5eilFREREpEhGo0Pn3HDn3GLn3FLn3E1J1t/lnJsX//nKObe52Lo7nHMLnHOLnHP3OudcJttaVaFwFFCPtoiIiIiUlJOpO3bOZQMPACcAecAs59xE7/3CxDbe+xuKbX89cGD870OBw4D+8dUfAUcBH2SqvVWlQFtEREREkslkj/YwYKn3fpn3vhAYB5xezvajgOfjf3ugGdAEaArkAusy2NYqS6SOqLyfiIiIiBSXyeiwM7Cy2O28+LIynHN7AT2A9wG899OAycCa+M9b3vtFSfa72jk32zk3e8OGDQE3Pz2JHu3m6tEWERERkWIyGWgny6n2KbY9H5jgvY8COOf2BfoAXbDg/Fjn3JFl7sz7R7z3Q7z3Qzp27BhQsytHqSMiIiIikkwmA+08oGux212A1Sm2PZ+itBGAM4Dp3vvt3vvtwCTg4Iy0sppCEaWOiIiIiEhZmYwOZwE9nXM9nHNNsGB6YumNnHO9gXbAtGKLvwWOcs7lOOdysYGQZVJH6oJEj3ZTzQwpIiIiIsVkLND23keA64C3sCB5vPd+gXPudufcacU2HQWM894XTyuZAHwNfAF8BnzmvX8tU22tDqWOiIiIiEgyGSvvB+C9fwN4o9SyP5e6fWuS/aLATzLZtqAUBdpKHRERERGRIooOqylR3k9VR0RERESkOAXa1aTUERERERFJRoF2NRVNWKNAW0RERESKKNCuplAkSm62IzsrWdlwEREREWmsFGhXU35hlGYq7SciIiIipSjQrqaCSJSmShsRERERkVIUaFdTKByjeRO9jCIiIiJSkiLEagqFlToiIiIiImUp0K6mUDiqiiMiIiIiUoYC7WoKhWOaFVJEREREylCEWE356tEWERERkSQUaFdTKBylqXK0RURERKQUBdrVVBCJ0byJAm0RERHykmzKAAAHRUlEQVQRKSmnthtQ3x3YrS29dmtV280QERERkTpGgXY1/efcgbXdBBERERGpg5Q6IiIiIiKSAQq0RUREREQyQIG2iIiIiEgGKNAWEREREckABdoiIiIiIhmgQFtEREREJAMUaIuIiIiIZIACbRERERGRDFCgLSIiIiKSAQq0RUREREQyQIG2iIiIiEgGKNAWEREREckABdoiIiIiIhngvPe13YZAOOc2ACsy/DAdgI0ZfgypG/ReNx56rxsPvdeNh97rxqO23uu9vPcdK9qowQTaNcE5N9t7P6S22yGZp/e68dB73XjovW489F43HnX9vVbqiIiIiIhIBijQFhERERHJAAXalfNIbTdAaoze68ZD73Xjofe68dB73XjU6fdaOdoiIiIiIhmgHm0RERERkQxQoJ0G59xw59xi59xS59xNtd0eCY5zrqtzbrJzbpFzboFz7hfx5e2dc+8455bEf7er7bZKMJxz2c65uc65/8Vv93DOzYi/1y8455rUdhul+pxzbZ1zE5xzX8aP70N0XDdMzrkb4ufv+c65551zzXRcNwzOucedc+udc/OLLUt6HDtzbzxW+9w5N6j2Wl5EgXYFnHPZwAPACKAvMMo517d2WyUBigA3eu/7AAcD18bf35uA97z3PYH34relYfgFsKjY7X8Cd8Xf6++BK2qlVRK0e4A3vff7AQOw91zHdQPjnOsM/BwY4r3vB2QD56PjuqF4Ahhealmq43gE0DP+czUwuobaWC4F2hUbBiz13i/z3hcC44DTa7lNEhDv/Rrv/afxv7dhH8adsff4yfhmTwIja6eFEiTnXBfgFODR+G0HHAtMiG+i97oBcM61Bo4EHgPw3hd67zej47qhygGaO+dygBbAGnRcNwje+6nAplKLUx3HpwNPeTMdaOuc26NmWpqaAu2KdQZWFrudF18mDYxzrjtwIDAD2M17vwYsGAc61V7LJEB3A78FYvHbuwKbvfeR+G0d3w3D3sAGYGw8TehR59wu6LhucLz3q4B/A99iAfYWYA46rhuyVMdxnYzXFGhXzCVZplItDYxzriXwIvBL7/3W2m6PBM85dyqw3ns/p/jiJJvq+K7/coBBwGjv/YHADpQm0iDF83NPB3oAewK7YCkEpem4bvjq5PlcgXbF8oCuxW53AVbXUlskA5xzuViQ/az3/qX44nWJS07x3+trq30SmMOA05xz32ApYMdiPdxt45ecQcd3Q5EH5HnvZ8RvT8ACbx3XDc/xwHLv/QbvfRh4CTgUHdcNWarjuE7Gawq0KzYL6BkfwdwEG2QxsZbbJAGJ5+g+Bizy3v+n2KqJwKXxvy8FXq3ptkmwvPc3e++7eO+7Y8fx+977C4HJwNnxzfReNwDe+7XASudc7/ii44CF6LhuiL4FDnbOtYifzxPvtY7rhivVcTwRuCRefeRgYEsixaQ2acKaNDjnTsZ6vrKBx733f63lJklAnHOHAx8CX1CUt/t7LE97PNANO5Gf470vPSBD6inn3NHAr733pzrn9sZ6uNsDc4GLvPcFtdk+qT7n3EBs0GsTYBlwOda5pOO6gXHO3Qach1WRmgtcieXm6riu55xzzwNHAx2AdcAtwCskOY7jX7Tux6qU7AQu997Pro12F6dAW0REREQkA5Q6IiIiIiKSAQq0RUREREQyQIG2iIiIiEgGKNAWEREREckABdoiIiIiIhmgQFtERMpwzh3tnPtfbbdDRKQ+U6AtIiIiIpIBCrRFROox59xFzrmZzrl5zrmHnXPZzrntzrk7nXOfOufec851jG870Dk33Tn3uXPuZedcu/jyfZ1z7zrnPovvs0/87ls65yY45750zj0bnxAC59w/nHML4/fz71p66iIidZ4CbRGReso51webEe8w7/1AIApcCOwCfOq9HwRMwWZTA3gK+J33vj82G2pi+bPAA977AcChQGLa4gOBXwJ9gb2Bw5xz7YEzgP3j9/OXzD5LEZH6S4G2iEj9dRwwGJjlnJsXv703EANeiG/zDHC4c64N0NZ7PyW+/EngSOdcK6Cz9/5lAO99yHu/M77NTO99nvc+BswDugNbgRDwqHPuTGyqYxERSUKBtohI/eWAJ733A+M/vb33tybZzldwH6kUFPs7CuR47yPAMOBFYCTwZiXbLCLSaCjQFhGpv94DznbOdQJwzrV3zu2FndvPjm9zAfCR934L8L1z7oj48ouBKd77rUCec25k/D6aOudapHpA51xLoI33/g0srWRgJp6YiEhDkFPbDRARkarx3i90zv0ReNs5lwWEgWuBHcD+zrk5wBYsjxvgUuCheCC9DLg8vvxi4GHn3O3x+zinnIdtBbzqnGuG9YbfEPDTEhFpMJz35V1RFBGR+sY5t91737K22yEi0tgpdUREREREJAPUoy0iIiIikgHq0RYRERERyQAF2iIiIiIiGaBAW0REREQkAxRoi4iIiIhkgAJtEREREZEMUKAtIiIiIpIB/w9sUocg1oCGDgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()  # Clear the figure\n",
    "plt.figure(figsize=(12,6))\n",
    "plt.plot(epochs, train_acc, '-', label='Training')\n",
    "plt.plot(epochs, val_acc, '--', label='Validation')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('accuracy')\n",
    "plt.legend();"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
